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/08/31 08:39:07 UTC
svn commit: r809469 - in /webservices/rampart/trunk/c/src/omxmlsec: axiom.c
tokens/token_binary_security_token.c xml_encryption.c xml_signature.c
Author: shankar
Date: Mon Aug 31 06:39:07 2009
New Revision: 809469
URL: http://svn.apache.org/viewvc?rev=809469&view=rev
Log:
improving log messages, error checking
Modified:
webservices/rampart/trunk/c/src/omxmlsec/axiom.c
webservices/rampart/trunk/c/src/omxmlsec/tokens/token_binary_security_token.c
webservices/rampart/trunk/c/src/omxmlsec/xml_encryption.c
webservices/rampart/trunk/c/src/omxmlsec/xml_signature.c
Modified: webservices/rampart/trunk/c/src/omxmlsec/axiom.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/axiom.c?rev=809469&r1=809468&r2=809469&view=diff
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/axiom.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/axiom.c Mon Aug 31 06:39:07 2009
@@ -396,60 +396,7 @@
const axutil_env_t *env,
axis2_char_t* buffer)
{
- axiom_document_t *doc = NULL;
- axiom_stax_builder_t *builder = NULL;
- axiom_xml_reader_t *reader = NULL;
- axiom_node_t *node = NULL;
-
- if(!buffer)
- {
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
- "[rampart]Deserialise method called with invalid buffer.");
- return NULL;
- }
- reader = axiom_xml_reader_create_for_memory(
- env, (void*)buffer, axutil_strlen(buffer), NULL, AXIS2_XML_PARSER_TYPE_BUFFER);
-
- if(!reader)
- {
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
- "[rampart]Could not be able to create axiom_xml_reader.");
- return NULL;
- }
-
- builder = axiom_stax_builder_create(env, reader);
- if(!builder)
- {
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
- "[rampart]Could not be able to create axiom_stax_builder.");
- return NULL;
- }
-
- doc = axiom_document_create(env, NULL, builder);
- if(!doc)
- {
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
- "[rampart]Could not be able to create axiom_document.");
- return NULL;
- }
-
- node = axiom_document_build_all(doc, env);
- if(!node)
- {
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
- "[rampart]Could not be able to deserialize the node.");
- axiom_document_free(doc, env);
- return NULL;
- }
-
- /* Free stax builder. The stax builder will free the reader. */
- axiom_stax_builder_free_self(builder, env);
- builder = NULL;
-
- axiom_document_free_self(doc, env);
- doc = NULL;
-
- return node;
+ return axiom_util_string_to_node(env, buffer);
}
/**
@@ -680,23 +627,5 @@
const axutil_env_t *env,
axiom_node_t *node)
{
- axis2_char_t* node_string = NULL;
- axiom_node_t *clone = NULL;
-
- if(!node)
- {
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
- "[rampart]Could not be able to clone the node. Given node is not valid.");
- return NULL;
- }
-
- node_string = axiom_node_sub_tree_to_string(node, env);
- clone = oxs_axiom_deserialize_node(env, node_string);
-
- if(node_string)
- {
- AXIS2_FREE(env->allocator, node_string);
- }
-
- return clone;
+ return axiom_util_clone_node(env, node);
}
Modified: webservices/rampart/trunk/c/src/omxmlsec/tokens/token_binary_security_token.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/tokens/token_binary_security_token.c?rev=809469&r1=809468&r2=809469&view=diff
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/tokens/token_binary_security_token.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/tokens/token_binary_security_token.c Mon Aug 31 06:39:07 2009
@@ -40,14 +40,14 @@
axiom_namespace_t *ns = NULL;
ns_obj = axiom_namespace_create(env, OXS_WSSE_NS, OXS_WSSE);
- ns = axiom_namespace_create(env,RAMPART_WSU_XMLNS,OXS_WSU);
+ ns = axiom_namespace_create(env, RAMPART_WSU_XMLNS, OXS_WSU);
- binary_security_token_ele = axiom_element_create(
- env, parent, OXS_NODE_BINARY_SECURITY_TOKEN, ns_obj, &binary_security_token_node);
- if (!binary_security_token_ele)
+ binary_security_token_ele = axiom_element_create(env, parent, OXS_NODE_BINARY_SECURITY_TOKEN,
+ ns_obj, &binary_security_token_node);
+ if(!binary_security_token_ele)
{
- AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
- "[rampart]Error creating %s element.", OXS_NODE_BINARY_SECURITY_TOKEN);
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Error creating %s element.",
+ OXS_NODE_BINARY_SECURITY_TOKEN);
axiom_namespace_free(ns_obj, env);
axiom_namespace_free(ns, env);
return NULL;
@@ -69,24 +69,24 @@
if(!id)
{
- id = oxs_util_generate_id(env,(axis2_char_t*)OXS_CERT_ID);
+ id = oxs_util_generate_id(env, (axis2_char_t*)OXS_CERT_ID);
}
- id_attr = axiom_attribute_create(env, OXS_ATTR_ID, id,ns);
- encoding_type_att = axiom_attribute_create(env, OXS_ATTR_ENCODING_TYPE, encoding_type, NULL);
- value_type_att = axiom_attribute_create(env, OXS_ATTR_VALUE_TYPE, value_type, NULL);
-
- ret = axiom_element_add_attribute(
- binary_security_token_ele, env, id_attr, binary_security_token_node);
- ret = axiom_element_add_attribute(
- binary_security_token_ele, env, encoding_type_att, binary_security_token_node);
- ret = axiom_element_add_attribute(
- binary_security_token_ele, env, value_type_att, binary_security_token_node);
+ id_attr = axiom_attribute_create(env, OXS_ATTR_ID, id, ns);
+ encoding_type_att = axiom_attribute_create(env, OXS_ATTR_ENCODING_TYPE, encoding_type, NULL);
+ value_type_att = axiom_attribute_create(env, OXS_ATTR_VALUE_TYPE, value_type, NULL);
+
+ ret = axiom_element_add_attribute(binary_security_token_ele, env, id_attr,
+ binary_security_token_node);
+ ret = axiom_element_add_attribute(binary_security_token_ele, env, encoding_type_att,
+ binary_security_token_node);
+ ret = axiom_element_add_attribute(binary_security_token_ele, env, value_type_att,
+ binary_security_token_node);
if(data)
{
- ret = axiom_element_set_text(
- binary_security_token_ele, env, data, binary_security_token_node);
+ ret = axiom_element_set_text(binary_security_token_ele, env, data,
+ binary_security_token_node);
}
return binary_security_token_node;
Modified: webservices/rampart/trunk/c/src/omxmlsec/xml_encryption.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/xml_encryption.c?rev=809469&r1=809468&r2=809469&view=diff
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/xml_encryption.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/xml_encryption.c Mon Aug 31 06:39:07 2009
@@ -47,10 +47,11 @@
*
*/
static axis2_status_t
-oxs_xml_enc_populate_stref_with_key_identifier(const axutil_env_t *env,
- oxs_asym_ctx_t *asym_ctx,
- axiom_node_t *stref_node,
- axis2_bool_t is_thumbprint)
+oxs_xml_enc_populate_stref_with_key_identifier(
+ const axutil_env_t *env,
+ oxs_asym_ctx_t *asym_ctx,
+ axiom_node_t *stref_node,
+ axis2_bool_t is_thumbprint)
{
axiom_node_t *key_identifier_node = NULL;
axis2_char_t *key_identifier = NULL;
@@ -58,20 +59,23 @@
oxs_x509_cert_t *cert = NULL;
cert = oxs_asym_ctx_get_certificate(asym_ctx, env);
- if(is_thumbprint){
+ if(is_thumbprint)
+ {
key_identifier = oxs_x509_cert_get_fingerprint(cert, env);
val_type = OXS_X509_TUMBP_PRINT_SHA1;
- }else{
+ }
+ else
+ {
key_identifier = oxs_x509_cert_get_key_identifier(cert, env);
val_type = OXS_X509_SUBJ_KI;
}
- if(!key_identifier){
+ if(!key_identifier)
+ {
return AXIS2_FAILURE;
}
/*Build KeyIdentifier node*/
- key_identifier_node = oxs_token_build_key_identifier_element(
- env, stref_node, OXS_ENCODING_BASE64BINARY,
- val_type, key_identifier);
+ key_identifier_node = oxs_token_build_key_identifier_element(env, stref_node,
+ OXS_ENCODING_BASE64BINARY, val_type, key_identifier);
return AXIS2_SUCCESS;
}
@@ -85,10 +89,11 @@
* </KeyInfo>
*/
static axis2_status_t
-oxs_xml_enc_populate_stref_with_bst(const axutil_env_t *env,
- oxs_asym_ctx_t *asym_ctx,
- axiom_node_t *stref_node,
- axiom_node_t *parent)
+oxs_xml_enc_populate_stref_with_bst(
+ const axutil_env_t *env,
+ oxs_asym_ctx_t *asym_ctx,
+ axiom_node_t *stref_node,
+ axiom_node_t *parent)
{
axiom_node_t *ref_node = NULL;
axiom_node_t *bst_node = NULL;
@@ -100,14 +105,16 @@
cert = oxs_asym_ctx_get_certificate(asym_ctx, env);
bst_data = oxs_x509_cert_get_data(cert, env);
- if(!bst_data){
+ if(!bst_data)
+ {
return AXIS2_FAILURE;
}
/*Generate an ID for BST*/
- id = oxs_util_generate_id(env,(axis2_char_t*)OXS_CERT_ID);
+ id = oxs_util_generate_id(env, (axis2_char_t*)OXS_CERT_ID);
/*Build BinarySecurityToken as a child of parent(wsse:Security)*/
- bst_node = oxs_token_build_binary_security_token_element(env, parent, id, OXS_ENCODING_BASE64BINARY, OXS_VALUE_X509V3, bst_data);
+ bst_node = oxs_token_build_binary_security_token_element(env, parent, id,
+ OXS_ENCODING_BASE64BINARY, OXS_VALUE_X509V3, bst_data);
/*Build a Reference to above BST*/
ref_id = axutil_stracat(env, OXS_LOCAL_REFERENCE_PREFIX, id);
@@ -125,9 +132,10 @@
* </KeyInfo>
*/
static axis2_status_t
-oxs_xml_enc_populate_stref_with_embedded(const axutil_env_t *env,
- oxs_asym_ctx_t *asym_ctx,
- axiom_node_t *stref_node)
+oxs_xml_enc_populate_stref_with_embedded(
+ const axutil_env_t *env,
+ oxs_asym_ctx_t *asym_ctx,
+ axiom_node_t *stref_node)
{
axiom_node_t *embedded_node = NULL;
axiom_node_t *bst_node = NULL;
@@ -137,13 +145,15 @@
cert = oxs_asym_ctx_get_certificate(asym_ctx, env);
bst_data = oxs_x509_cert_get_data(cert, env);
- if(!bst_data){
+ if(!bst_data)
+ {
return AXIS2_FAILURE;
}
/*Build embedded token*/
embedded_node = oxs_token_build_embedded_element(env, stref_node, NULL);
/*Build BinarySecurityToken*/
- bst_node = oxs_token_build_binary_security_token_element(env, embedded_node, NULL, OXS_ENCODING_BASE64BINARY, OXS_VALUE_X509V3, bst_data);
+ bst_node = oxs_token_build_binary_security_token_element(env, embedded_node, NULL,
+ OXS_ENCODING_BASE64BINARY, OXS_VALUE_X509V3, bst_data);
return AXIS2_SUCCESS;
}
@@ -161,9 +171,10 @@
* </KeyInfo>
*/
static axis2_status_t
-oxs_xml_enc_populate_stref_with_issuer_serial(const axutil_env_t *env,
- oxs_asym_ctx_t *asym_ctx,
- axiom_node_t *stref_node)
+oxs_xml_enc_populate_stref_with_issuer_serial(
+ const axutil_env_t *env,
+ oxs_asym_ctx_t *asym_ctx,
+ axiom_node_t *stref_node)
{
axiom_node_t *x509_data_node = NULL;
axiom_node_t *issuer_serial_node = NULL;
@@ -175,15 +186,17 @@
cert = oxs_asym_ctx_get_certificate(asym_ctx, env);
issuer_name = oxs_x509_cert_get_issuer(cert, env);
- serial = oxs_x509_cert_get_serial_number(cert, env);
- if((!issuer_name) || (serial<0)){
+ serial = oxs_x509_cert_get_serial_number(cert, env);
+ if((!issuer_name) || (serial < 0))
+ {
return AXIS2_FAILURE;
}
sprintf(serial_number, "%d", serial);
/*Build x509Data*/
x509_data_node = oxs_token_build_x509_data_element(env, stref_node);
- issuer_serial_node = oxs_token_build_x509_issuer_serial_with_data(env, x509_data_node, issuer_name, serial_number);
+ issuer_serial_node = oxs_token_build_x509_issuer_serial_with_data(env, x509_data_node,
+ issuer_name, serial_number);
return AXIS2_SUCCESS;
}
@@ -196,21 +209,21 @@
{
axiom_node_t *st_ref_node = NULL;
- st_ref_node = oxs_axiom_get_first_child_node_by_name(
- env, key_info_node, OXS_NODE_SECURITY_TOKEN_REFRENCE, OXS_WSSE_XMLNS, OXS_WSSE);
+ st_ref_node = oxs_axiom_get_first_child_node_by_name(env, key_info_node,
+ OXS_NODE_SECURITY_TOKEN_REFRENCE, OXS_WSSE_XMLNS, OXS_WSSE);
if(!st_ref_node)
{
return AXIS2_FAILURE;
}
/*
- WSS-Core specification suggests
- 1. Resolve any <wsse:Reference> elements (specified within
- <wsse:SecurityTokenReference>).
- 2. Resolve any <wsse:KeyIdentifier> elements (specified within
- <wsse:SecurityTokenReference>).
- 3. Resolve any <ds:KeyName> elements. NOT PERMITTED by WS-i
- 4. Resolve any other <ds:KeyInfo> elements. NOT PERMITTED by WS-i
- */
+ WSS-Core specification suggests
+ 1. Resolve any <wsse:Reference> elements (specified within
+ <wsse:SecurityTokenReference>).
+ 2. Resolve any <wsse:KeyIdentifier> elements (specified within
+ <wsse:SecurityTokenReference>).
+ 3. Resolve any <ds:KeyName> elements. NOT PERMITTED by WS-i
+ 4. Resolve any other <ds:KeyInfo> elements. NOT PERMITTED by WS-i
+ */
/*
* TODO: This method should get the key from the key_node. Currently key is taken from
@@ -222,27 +235,31 @@
/*public functions*/
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_enc_encrypt_node(const axutil_env_t *env,
- oxs_ctx_t * enc_ctx,
- axiom_node_t *node,
- axiom_node_t **enc_type_node,
- axiom_node_t *security_token_reference)
+oxs_xml_enc_encrypt_node(
+ const axutil_env_t *env,
+ oxs_ctx_t * enc_ctx,
+ axiom_node_t *node,
+ axiom_node_t **enc_type_node,
+ axiom_node_t *security_token_reference)
{
axis2_char_t *serialized_data = NULL;
- oxs_buffer_t *serialized_buf= NULL;
+ oxs_buffer_t *serialized_buf = NULL;
axis2_status_t ret = AXIS2_FAILURE;
/*Serialize node*/
/*serialized_data = axiom_node_to_string(node, env);*/
serialized_data = axiom_node_to_string_non_optimized(node, env);
serialized_buf = oxs_buffer_create(env);
- ret = oxs_buffer_populate(serialized_buf, env, (unsigned char *)serialized_data, axutil_strlen(serialized_data));
+ ret = oxs_buffer_populate(serialized_buf, env, (unsigned char *)serialized_data, axutil_strlen(
+ serialized_data));
/*We call encrypt_data*/
- ret = oxs_xml_enc_encrypt_data(env, enc_ctx, serialized_buf, enc_type_node, security_token_reference);
+ ret = oxs_xml_enc_encrypt_data(env, enc_ctx, serialized_buf, enc_type_node,
+ security_token_reference);
/*Remove the node from the parent*/
- if(AXIS2_SUCCESS == ret){
+ if(AXIS2_SUCCESS == ret)
+ {
axiom_node_detach(node, env);
axiom_node_free_tree(node, env);
node = NULL;
@@ -260,13 +277,14 @@
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_enc_encrypt_data(const axutil_env_t *env,
- oxs_ctx_t * enc_ctx,
- oxs_buffer_t *content_buf,
- axiom_node_t **enc_type_node,
- axiom_node_t *security_token_reference_node)
+oxs_xml_enc_encrypt_data(
+ const axutil_env_t *env,
+ oxs_ctx_t * enc_ctx,
+ oxs_buffer_t *content_buf,
+ axiom_node_t **enc_type_node,
+ axiom_node_t *security_token_reference_node)
{
- oxs_buffer_t *result_buf= NULL;
+ oxs_buffer_t *result_buf = NULL;
oxs_key_t *sym_key = NULL;
axis2_char_t *sym_algo = NULL;
axiom_node_t *enc_mtd_node = NULL;
@@ -309,12 +327,14 @@
key_info_node = oxs_token_build_key_info_element(env, *enc_type_node);
str_node = oxs_token_build_security_token_reference_element(env, key_info_node);
- ref_node = oxs_token_build_reference_element(env, str_node, oxs_ctx_get_ref_key_name(enc_ctx, env), NULL);
+ ref_node = oxs_token_build_reference_element(env, str_node, oxs_ctx_get_ref_key_name(
+ enc_ctx, env), NULL);
}
/*Create CipherData element and populate*/
cd_node = oxs_token_build_cipher_data_element(env, *enc_type_node);
- cv_node = oxs_token_build_cipher_value_element(env, cd_node, (axis2_char_t*)oxs_buffer_get_data(result_buf, env));
+ cv_node = oxs_token_build_cipher_value_element(env, cd_node,
+ (axis2_char_t*)oxs_buffer_get_data(result_buf, env));
/*Free buffers*/
oxs_buffer_free(result_buf, env);
@@ -324,10 +344,11 @@
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_enc_decrypt_node(const axutil_env_t *env,
- oxs_ctx_t * enc_ctx,
- axiom_node_t *enc_type_node,
- axiom_node_t **decrypted_node)
+oxs_xml_enc_decrypt_node(
+ const axutil_env_t *env,
+ oxs_ctx_t * enc_ctx,
+ axiom_node_t *enc_type_node,
+ axiom_node_t **decrypted_node)
{
axiom_node_t *deserialized_node = NULL;
axiom_node_t *parent_of_enc_node = NULL;
@@ -340,15 +361,19 @@
/*Decrypt*/
status = oxs_xml_enc_decrypt_data(env, enc_ctx, enc_type_node, result_buf);
- if(AXIS2_FAILURE == status){
+ if(AXIS2_FAILURE == status)
+ {
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED, "Data encryption failed");
return AXIS2_FAILURE;
}
- decrypted_data = axutil_strmemdup(oxs_buffer_get_data(result_buf, env), oxs_buffer_get_size(result_buf, env), env);
+ decrypted_data = axutil_strmemdup(oxs_buffer_get_data(result_buf, env), oxs_buffer_get_size(
+ result_buf, env), env);
/*De-serialize the decrypted content to build the node*/
deserialized_node = (axiom_node_t*)oxs_axiom_deserialize_node(env, decrypted_data);
- if(!deserialized_node){
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED,"Cannot deserialize a node from the content.\n%s", decrypted_data);
+ if(!deserialized_node)
+ {
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED,
+ "Cannot deserialize a node from the content.\n%s", decrypted_data);
return AXIS2_FAILURE;
}
/*Assign deserialized_node to the reference passed*/
@@ -360,7 +385,6 @@
axiom_node_insert_sibling_after(enc_type_node, env, deserialized_node);
axiom_node_detach(enc_type_node, env);
-
axiom_node_free_tree(enc_type_node, env);
enc_type_node = NULL;
@@ -376,10 +400,11 @@
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_enc_decrypt_data(const axutil_env_t *env,
- oxs_ctx_t * enc_ctx,
- axiom_node_t *enc_type_node,
- oxs_buffer_t *result_buf)
+oxs_xml_enc_decrypt_data(
+ const axutil_env_t *env,
+ oxs_ctx_t * enc_ctx,
+ axiom_node_t *enc_type_node,
+ oxs_buffer_t *result_buf)
{
axiom_node_t *enc_mtd_node = NULL;
axiom_node_t *cd_node = NULL;
@@ -392,46 +417,70 @@
oxs_buffer_t *input_buf = NULL;
axis2_status_t status = AXIS2_FAILURE;
- /*Get the symmetric encryption algorithm*/
- enc_mtd_node = oxs_axiom_get_first_child_node_by_name(env, enc_type_node, OXS_NODE_ENCRYPTION_METHOD,OXS_ENC_NS,OXS_XENC);
+ /* Get the symmetric encryption algorithm */
+ enc_mtd_node = oxs_axiom_get_first_child_node_by_name(env, enc_type_node,
+ OXS_NODE_ENCRYPTION_METHOD, OXS_ENC_NS, OXS_XENC);
+ if(!enc_mtd_node)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Cannot find encryption method node");
+ return AXIS2_FAILURE;
+ }
+
sym_algo = oxs_token_get_encryption_method(env, enc_mtd_node);
- if(!sym_algo){
+ if(!sym_algo)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Cannot find encryption method");
return AXIS2_FAILURE;
}
- /*Get ID, Type, MimeType attributes from the EncryptedDataNode*/
+
+ /* Get ID, Type, MimeType attributes from the EncryptedDataNode */
id = oxs_axiom_get_attribute_value_of_node_by_name(env, enc_type_node, OXS_ATTR_ID, NULL);
type = oxs_axiom_get_attribute_value_of_node_by_name(env, enc_type_node, OXS_ATTR_TYPE, NULL);
- /*Populate the context for future use*/
+ /* Populate the context for future use */
oxs_ctx_set_enc_mtd_algorithm(enc_ctx, env, sym_algo);
oxs_ctx_set_id(enc_ctx, env, id);
oxs_ctx_set_type(enc_ctx, env, type);
- /*Get the cipher value*/
- cd_node = oxs_axiom_get_first_child_node_by_name(env, enc_type_node, OXS_NODE_CIPHER_DATA,OXS_ENC_NS,OXS_XENC);
- cv_node = oxs_axiom_get_first_child_node_by_name(env, cd_node, OXS_NODE_CIPHER_VALUE,OXS_ENC_NS,OXS_XENC);
+ /* Get the cipher value */
+ cd_node = oxs_axiom_get_first_child_node_by_name(env, enc_type_node, OXS_NODE_CIPHER_DATA,
+ OXS_ENC_NS, OXS_XENC);
+ if(!cd_node)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Cannot find cipher data node");
+ return AXIS2_FAILURE;
+ }
+
+ cv_node = oxs_axiom_get_first_child_node_by_name(env, cd_node, OXS_NODE_CIPHER_VALUE,
+ OXS_ENC_NS, OXS_XENC);
+ if(!cv_node)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Cannot find cipher value node");
+ return AXIS2_FAILURE;
+ }
+
cipher_val = oxs_token_get_cipher_value(env, cv_node);
+ if(!cipher_val)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart]Cannot find cipher value");
+ return AXIS2_FAILURE;
+ }
- /*We need to remove new lines if any*/
+ /* We need to remove new lines if any */
new_cipher_val = oxs_util_get_newline_removed_string(env, cipher_val);
- /*eof NEW CODE*/
- /*Create input buffer with cipher data obtained*/
+ /* Create input buffer with cipher data obtained */
input_buf = oxs_buffer_create(env);
- oxs_buffer_populate(input_buf, env, (unsigned char*)new_cipher_val, axutil_strlen(new_cipher_val) );
+ oxs_buffer_populate(input_buf, env, (unsigned char*)new_cipher_val,
+ axutil_strlen(new_cipher_val));
- /*Decrypt*/
+ /* Decrypt */
oxs_ctx_set_operation(enc_ctx, env, OXS_CTX_OPERATION_DECRYPT);
- status = oxs_encryption_symmetric_crypt(env, enc_ctx, input_buf, result_buf);
+ status = oxs_encryption_symmetric_crypt(env, enc_ctx, input_buf, result_buf);
/*Free*/
-
oxs_buffer_free(input_buf, env);
input_buf = NULL;
-
- /*AXIS2_FREE(env->allocator, cipher_val);
- cipher_val = NULL;*/
-
AXIS2_FREE(env->allocator, new_cipher_val);
new_cipher_val = NULL;
@@ -440,11 +489,12 @@
/*For SOAP this parent is the wsse:Security node*/
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_enc_encrypt_key(const axutil_env_t *env,
- oxs_asym_ctx_t * asym_ctx,
- axiom_node_t *parent,
- oxs_key_t *sym_key,
- axutil_array_list_t *id_list)
+oxs_xml_enc_encrypt_key(
+ const axutil_env_t *env,
+ oxs_asym_ctx_t * asym_ctx,
+ axiom_node_t *parent,
+ oxs_key_t *sym_key,
+ axutil_array_list_t *id_list)
{
axis2_char_t *algorithm = NULL;
axis2_char_t *encrypted_key_data = NULL;
@@ -475,9 +525,10 @@
oxs_buffer_free(input, env);
input = NULL;
- if(AXIS2_FAILURE == status){
+ if(AXIS2_FAILURE == status)
+ {
oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED,
- "Assymmetric key encryption failed");
+ "Assymmetric key encryption failed");
return AXIS2_FAILURE;
}
/*Get the encrypted key*/
@@ -492,33 +543,46 @@
stref_node = oxs_token_build_security_token_reference_element(env, key_info_node);
/*Get the ST REF pattern. If not set the default*/
st_ref_pattern = oxs_asym_ctx_get_st_ref_pattern(asym_ctx, env);
- if((!st_ref_pattern) || (0 == axutil_strcmp(st_ref_pattern, ""))){
+ if((!st_ref_pattern) || (0 == axutil_strcmp(st_ref_pattern, "")))
+ {
st_ref_pattern = OXS_STR_DEFAULT;
}
- if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_ISSUER_SERIAL)){
+ if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_ISSUER_SERIAL))
+ {
status = oxs_xml_enc_populate_stref_with_issuer_serial(env, asym_ctx, stref_node);
- }else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_EMBEDDED)){
+ }
+ else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_EMBEDDED))
+ {
status = oxs_xml_enc_populate_stref_with_embedded(env, asym_ctx, stref_node);
- }else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_DIRECT_REFERENCE)){
+ }
+ else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_DIRECT_REFERENCE))
+ {
status = oxs_xml_enc_populate_stref_with_bst(env, asym_ctx, stref_node, parent);
- }else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_KEY_IDENTIFIER)){
- status = oxs_xml_enc_populate_stref_with_key_identifier(env, asym_ctx, stref_node, AXIS2_FALSE);
- }else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_THUMB_PRINT)){
+ }
+ else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_KEY_IDENTIFIER))
+ {
+ status = oxs_xml_enc_populate_stref_with_key_identifier(env, asym_ctx, stref_node,
+ AXIS2_FALSE);
+ }
+ else if(0 == axutil_strcmp(st_ref_pattern, OXS_STR_THUMB_PRINT))
+ {
/*TODO: Need to support Thumbprint Ref*/
- status = oxs_xml_enc_populate_stref_with_key_identifier(env, asym_ctx, stref_node, AXIS2_TRUE);
+ status = oxs_xml_enc_populate_stref_with_key_identifier(env, asym_ctx, stref_node,
+ AXIS2_TRUE);
}
cd_node = oxs_token_build_cipher_data_element(env, encrypted_key_node);
- cv_node = oxs_token_build_cipher_value_element(env, cd_node, encrypted_key_data);
+ cv_node = oxs_token_build_cipher_value_element(env, cd_node, encrypted_key_data);
/*If and only if the id_list the present, we create the reference list*/
- if(id_list){
+ if(id_list)
+ {
oxs_token_build_data_reference_list(env, encrypted_key_node, id_list);
}
/*calculate the EncryptedKeySHA1 and set as the key_sha*/
decoded_len = axutil_base64_decode_len(encrypted_key_data);
decoded_enc_sec = AXIS2_MALLOC(env->allocator, decoded_len);
- axutil_base64_decode_binary((unsigned char*)decoded_enc_sec, encrypted_key_data);
+ axutil_base64_decode_binary((unsigned char*)decoded_enc_sec, encrypted_key_data);
encrypted_key_hash = openssl_sha1(env, decoded_enc_sec, decoded_len);
oxs_key_set_key_sha(sym_key, env, encrypted_key_hash);
AXIS2_FREE(env->allocator, decoded_enc_sec);
@@ -534,11 +598,12 @@
* Inspect the key node. Then populate the sym_key
*/
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_enc_decrypt_key(const axutil_env_t *env,
- oxs_asym_ctx_t * asym_ctx,
- axiom_node_t *parent,
- axiom_node_t *encrypted_key_node,
- oxs_key_t *key)
+oxs_xml_enc_decrypt_key(
+ const axutil_env_t *env,
+ oxs_asym_ctx_t * asym_ctx,
+ axiom_node_t *parent,
+ axiom_node_t *encrypted_key_node,
+ oxs_key_t *key)
{
axiom_node_t *enc_mtd_node = NULL;
axiom_node_t *key_info_node = NULL;
@@ -556,33 +621,40 @@
axis2_char_t *decoded_enc_sec = NULL;
/*Get encryption method algorithm*/
- enc_mtd_node = oxs_axiom_get_first_child_node_by_name(env, encrypted_key_node, OXS_NODE_ENCRYPTION_METHOD,OXS_ENC_NS,OXS_XENC);
+ enc_mtd_node = oxs_axiom_get_first_child_node_by_name(env, encrypted_key_node,
+ OXS_NODE_ENCRYPTION_METHOD, OXS_ENC_NS, OXS_XENC);
enc_mtd_algo = oxs_token_get_encryption_method(env, enc_mtd_node);
- if(!enc_mtd_algo){
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED, "Cannot find the Encryption method");
+ if(!enc_mtd_algo)
+ {
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED,
+ "Cannot find the Encryption method");
return AXIS2_FAILURE;
}
/*Get cipher data*/
- cd_node = oxs_axiom_get_first_child_node_by_name(env, encrypted_key_node, OXS_NODE_CIPHER_DATA,OXS_ENC_NS,OXS_XENC);
+ cd_node = oxs_axiom_get_first_child_node_by_name(env, encrypted_key_node, OXS_NODE_CIPHER_DATA,
+ OXS_ENC_NS, OXS_XENC);
cipher_val = oxs_token_get_cipher_value_from_cipher_data(env, cd_node);
- if(!cipher_val){
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED, "Cannot find the cipher value for key decryption");
+ if(!cipher_val)
+ {
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_ENCRYPT_FAILED,
+ "Cannot find the cipher value for key decryption");
return AXIS2_FAILURE;
}
new_cipher_val = oxs_util_get_newline_removed_string(env, cipher_val);
/*Get key used to encrypt*/
- key_info_node = oxs_axiom_get_first_child_node_by_name(env, encrypted_key_node, OXS_NODE_KEY_INFO,OXS_DSIG_NS,OXS_DS);
+ key_info_node = oxs_axiom_get_first_child_node_by_name(env, encrypted_key_node,
+ OXS_NODE_KEY_INFO, OXS_DSIG_NS, OXS_DS);
status = oxs_xml_enc_process_key_info(env, asym_ctx, key_info_node, parent);
/*Right now we support KeyInfo -> SecurityTokenReference -> Reference
- KeyInfo -> SecurityTokenReference -> X509IssuerSerial */
-
+ KeyInfo -> SecurityTokenReference -> X509IssuerSerial */
/*Get the pkey used to decrypt the session key. If found set it to the asym_ctx*/
/*Create the input buffer*/
input_buf = oxs_buffer_create(env);
- oxs_buffer_populate(input_buf, env, (unsigned char*)new_cipher_val, axutil_strlen(new_cipher_val));
+ oxs_buffer_populate(input_buf, env, (unsigned char*)new_cipher_val, axutil_strlen(
+ new_cipher_val));
/*Create a results buffer*/
result_buf = oxs_buffer_create(env);
@@ -593,28 +665,26 @@
oxs_buffer_free(input_buf, env);
input_buf = NULL;
- /*calculate the EncryptedKeySHA1 and set as the key_sha*/
+ /*calculate the EncryptedKeySHA1 and set as the key_sha*/
decoded_len = axutil_base64_decode_len(new_cipher_val);
decoded_enc_sec = AXIS2_MALLOC(env->allocator, decoded_len);
- axutil_base64_decode_binary((unsigned char*)decoded_enc_sec, new_cipher_val);
+ axutil_base64_decode_binary((unsigned char*)decoded_enc_sec, new_cipher_val);
encrypted_key_hash = openssl_sha1(env, decoded_enc_sec, decoded_len);
AXIS2_FREE(env->allocator, decoded_enc_sec);
AXIS2_FREE(env->allocator, new_cipher_val);
new_cipher_val = NULL;
-
- if(AXIS2_FAILURE == status){
+ if(AXIS2_FAILURE == status)
+ {
return AXIS2_FAILURE;
}
- key_name = oxs_axiom_get_attribute_value_of_node_by_name(env, encrypted_key_node, OXS_ATTR_ID, NULL);
+ key_name = oxs_axiom_get_attribute_value_of_node_by_name(env, encrypted_key_node, OXS_ATTR_ID,
+ NULL);
/*Populate the key with the data in the result buffer*/
- oxs_key_populate(key, env,
- oxs_buffer_get_data(result_buf, env),
- key_name,
- oxs_buffer_get_size(result_buf, env),
- OXS_KEY_USAGE_SESSION );
+ oxs_key_populate(key, env, oxs_buffer_get_data(result_buf, env), key_name, oxs_buffer_get_size(
+ result_buf, env), OXS_KEY_USAGE_SESSION);
oxs_key_set_key_sha(key, env, encrypted_key_hash);
/*Free*/
Modified: webservices/rampart/trunk/c/src/omxmlsec/xml_signature.c
URL: http://svn.apache.org/viewvc/webservices/rampart/trunk/c/src/omxmlsec/xml_signature.c?rev=809469&r1=809468&r2=809469&view=diff
==============================================================================
--- webservices/rampart/trunk/c/src/omxmlsec/xml_signature.c (original)
+++ webservices/rampart/trunk/c/src/omxmlsec/xml_signature.c Mon Aug 31 06:39:07 2009
@@ -34,31 +34,33 @@
#include <oxs_transforms_factory.h>
#include <oxs_tokens.h>
#include <axiom_util.h>
-/*Private functions*/
-/*This method is common for both signing and verification*/
+/* This method is common for both signing and verification */
static axis2_char_t *
-oxs_xml_sig_transform_n_digest(const axutil_env_t *env,
- axiom_node_t *node,
- axutil_array_list_t *transforms,
- axis2_char_t *digest_mtd)
+oxs_xml_sig_transform_n_digest(
+ const axutil_env_t *env,
+ axiom_node_t *node,
+ axutil_array_list_t *transforms,
+ axis2_char_t *digest_mtd)
{
axis2_char_t *serialized_node = NULL;
axis2_char_t *digest = NULL;
- axiom_node_t *ori_node = NULL, *sig_node = NULL;
- oxs_tr_dtype_t output_dtype = OXS_TRANSFORM_TYPE_UNKNOWN;/*This will always be the current dtype*/
+ axiom_node_t *ori_node = NULL, *sig_node = NULL;
+ oxs_tr_dtype_t output_dtype = OXS_TRANSFORM_TYPE_UNKNOWN;/*This will always be the current dtype*/
void *tr_output = NULL;
int i = 0;
- if((transforms) && (0 < axutil_array_list_size(transforms, env))){
-
+ if((transforms) && (0 < axutil_array_list_size(transforms, env)))
+ {
+
output_dtype = OXS_TRANSFORM_TYPE_NODE; /*We always begin with a node*/
tr_output = node; /*The first transformation is applied to the node*/
/*LOOP: Apply transforms. For example exclusive C14N*/
- for (i = 0; i < axutil_array_list_size(transforms, env); i++){
+ for(i = 0; i < axutil_array_list_size(transforms, env); i++)
+ {
oxs_transform_t *tr = NULL;
oxs_transform_tr_func tr_func = NULL;
oxs_tr_dtype_t input_dtype = OXS_TRANSFORM_TYPE_UNKNOWN;
@@ -73,54 +75,83 @@
/*Prepare the input*/
/*If the required input type is CHAR and what we have is a NODE*/
- if((input_dtype == OXS_TRANSFORM_TYPE_CHAR) && (output_dtype == OXS_TRANSFORM_TYPE_NODE)){
+ if((input_dtype == OXS_TRANSFORM_TYPE_CHAR)
+ && (output_dtype == OXS_TRANSFORM_TYPE_NODE))
+ {
/*Serialize*/
tr_input = axiom_node_to_string((axiom_node_t*)tr_output, env);
/*If the required input type is NODE and what we have is a CHAR*/
- }else if((input_dtype == OXS_TRANSFORM_TYPE_NODE) && (output_dtype == OXS_TRANSFORM_TYPE_CHAR)){
+ }
+ else if((input_dtype == OXS_TRANSFORM_TYPE_NODE) && (output_dtype
+ == OXS_TRANSFORM_TYPE_CHAR))
+ {
/*De-serialize*/
- tr_input = oxs_axiom_deserialize_node(env, (axis2_char_t *)tr_output);
- }else if((input_dtype == OXS_TRANSFORM_TYPE_NODE) && (output_dtype == OXS_TRANSFORM_TYPE_NODE_ARRAY_LIST)){
- ori_node = axutil_array_list_get((axutil_array_list_t*)tr_output, env, 0);
- sig_node = axutil_array_list_get((axutil_array_list_t*)tr_output, env, 1);
- tr_input = ori_node;
- }else if((input_dtype == OXS_TRANSFORM_TYPE_CHAR) && (output_dtype == OXS_TRANSFORM_TYPE_NODE_ARRAY_LIST)){
- ori_node = axutil_array_list_get((axutil_array_list_t*)tr_output, env, 0);
- sig_node = axutil_array_list_get((axutil_array_list_t*)tr_output, env, 1);
- tr_input = axiom_node_to_string(ori_node, env);
- }else{
+ tr_input = oxs_axiom_deserialize_node(env, (axis2_char_t *)tr_output);
+ }
+ else if((input_dtype == OXS_TRANSFORM_TYPE_NODE) && (output_dtype
+ == OXS_TRANSFORM_TYPE_NODE_ARRAY_LIST))
+ {
+ ori_node = axutil_array_list_get((axutil_array_list_t*)tr_output, env, 0);
+ sig_node = axutil_array_list_get((axutil_array_list_t*)tr_output, env, 1);
+ tr_input = ori_node;
+ }
+ else if((input_dtype == OXS_TRANSFORM_TYPE_CHAR) && (output_dtype
+ == OXS_TRANSFORM_TYPE_NODE_ARRAY_LIST))
+ {
+ ori_node = axutil_array_list_get((axutil_array_list_t*)tr_output, env, 0);
+ sig_node = axutil_array_list_get((axutil_array_list_t*)tr_output, env, 1);
+ tr_input = axiom_node_to_string(ori_node, env);
+ }
+ else
+ {
/*Let it go as it is. */
tr_input = tr_output;
}
/*Apply transform*/
- if(tr_func){
+ if(tr_func)
+ {
output_dtype = (*tr_func)(env, tr_input, input_dtype, &tr_output);
- }else{
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,"Cannot get the transform implementation for %s", tr_id);
+ }
+ else
+ {
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,
+ "Cannot get the transform implementation for %s", tr_id);
}
/*If the output data type is unknown OR the output is NULL its an error*/
- if((output_dtype == OXS_TRANSFORM_TYPE_UNKNOWN) || (!tr_output)){
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,"Transform failed for %s", tr_id);
+ if((output_dtype == OXS_TRANSFORM_TYPE_UNKNOWN) || (!tr_output))
+ {
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,
+ "Transform failed for %s", tr_id);
return NULL;
}
- }/*eof for loop*/
+ }/*eof for loop*/
/*We have applied all our transforms now*/
/*Serialize node*/
- if(OXS_TRANSFORM_TYPE_NODE == output_dtype ){
+ if(OXS_TRANSFORM_TYPE_NODE == output_dtype)
+ {
serialized_node = axiom_node_to_string((axiom_node_t*)tr_output, env);
- }else if(OXS_TRANSFORM_TYPE_CHAR == output_dtype){
+ }
+ else if(OXS_TRANSFORM_TYPE_CHAR == output_dtype)
+ {
serialized_node = (axis2_char_t*)tr_output;
}
- else if(OXS_TRANSFORM_TYPE_NODE_ARRAY_LIST == output_dtype){
- ori_node = (axiom_node_t*)axutil_array_list_get((axutil_array_list_t*)tr_output, env, 0);
- sig_node = (axiom_node_t*)axutil_array_list_get((axutil_array_list_t*)tr_output, env, 1);
- serialized_node = axiom_node_to_string(ori_node, env);
- }
- else{
+ else if(OXS_TRANSFORM_TYPE_NODE_ARRAY_LIST == output_dtype)
+ {
+ ori_node
+ = (axiom_node_t*)axutil_array_list_get((axutil_array_list_t*)tr_output, env, 0);
+ sig_node
+ = (axiom_node_t*)axutil_array_list_get((axutil_array_list_t*)tr_output, env, 1);
+ serialized_node = axiom_node_to_string(ori_node, env);
+ }
+ else
+ {
/*Error*/
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,"Unsupported transform data type %d", output_dtype);
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,
+ "Unsupported transform data type %d", output_dtype);
}
- }else{
+ }
+ else
+ {
/*No transforms defined. Thus we simply direct the node, to make the digest*/
serialized_node = axiom_node_to_string(node, env);
}
@@ -139,11 +170,13 @@
"Unsupported digest method %s", digest_mtd);
return NULL;
}
-
- if(ori_node && sig_node){
- axiom_node_add_child(ori_node, env, sig_node);
- }
- if(serialized_node){
+
+ if(ori_node && sig_node)
+ {
+ axiom_node_add_child(ori_node, env, sig_node);
+ }
+ if(serialized_node)
+ {
AXIS2_FREE(env->allocator, serialized_node);
serialized_node = NULL;
}
@@ -152,16 +185,17 @@
/*parent is ds:SignedInfo*/
static axis2_status_t
-oxs_xml_sig_build_reference(const axutil_env_t *env,
- axiom_node_t *parent,
- oxs_sign_part_t *sign_part)
+oxs_xml_sig_build_reference(
+ const axutil_env_t *env,
+ axiom_node_t *parent,
+ oxs_sign_part_t *sign_part)
{
axis2_char_t *digest = NULL;
axis2_char_t *digest_mtd = NULL;
axis2_char_t *ref_id = NULL;
axis2_char_t *id = NULL, *id_name = NULL;
- axiom_namespace_t *ns = NULL;
- axis2_char_t *ns_uri = NULL;
+ axiom_namespace_t *ns = NULL;
+ axis2_char_t *ns_uri = NULL;
axutil_array_list_t *transforms = NULL;
axiom_node_t *node = NULL;
axiom_node_t *reference_node = NULL;
@@ -172,25 +206,24 @@
/*Get the node to digest*/
node = oxs_sign_part_get_node(sign_part, env);
- id_name = oxs_sign_part_get_id_name(sign_part, env);
- ns = oxs_sign_part_get_sign_namespace(sign_part, env);
+ id_name = oxs_sign_part_get_id_name(sign_part, env);
+ ns = oxs_sign_part_get_sign_namespace(sign_part, env);
- if(ns)
- ns_uri = axiom_namespace_get_uri(ns, env);
- else if (!ns && !id_name)
- ns_uri = OXS_WSU_XMLNS;
+ if(ns)
+ ns_uri = axiom_namespace_get_uri(ns, env);
+ else if(!ns && !id_name)
+ ns_uri = OXS_WSU_XMLNS;
else
ns_uri = NULL;
- if(!id_name)
- id_name = OXS_ATTR_ID;
+ if(!id_name)
+ id_name = OXS_ATTR_ID;
/*Get the reference ID from the node and hence to the ds:Reference node*/
- id = oxs_axiom_get_attribute_value_of_node_by_name(env, node, id_name,
- ns_uri);
+ id = oxs_axiom_get_attribute_value_of_node_by_name(env, node, id_name, ns_uri);
ref_id = axutil_stracat(env, OXS_LOCAL_REFERENCE_PREFIX, id);/* <ds:Reference URI="#id">*/
- reference_node = oxs_token_build_ds_reference_element(env, parent ,NULL, ref_id, NULL);
+ reference_node = oxs_token_build_ds_reference_element(env, parent, NULL, ref_id, NULL);
AXIS2_FREE(env->allocator, ref_id);
ref_id = NULL;
@@ -208,11 +241,13 @@
}
/*Build ds:Transforms node and its children*/
- if((transforms) && (0 < axutil_array_list_size(transforms, env))){
+ if((transforms) && (0 < axutil_array_list_size(transforms, env)))
+ {
axiom_node_t *transforms_node = NULL;
transforms_node = oxs_token_build_transforms_element(env, reference_node);
- for (i = 0; i < axutil_array_list_size(transforms, env); i++){
+ for(i = 0; i < axutil_array_list_size(transforms, env); i++)
+ {
oxs_transform_t *tr = NULL;
axis2_char_t *tr_id = NULL;
@@ -236,10 +271,11 @@
* C14N -> Serialize -> Sign the <SignedInfo> element
*/
static axis2_status_t
-oxs_xml_sig_sign_signed_info(const axutil_env_t *env,
- axiom_node_t *signature_node,
- axiom_node_t *signed_info_node,
- oxs_sign_ctx_t *sign_ctx)
+oxs_xml_sig_sign_signed_info(
+ const axutil_env_t *env,
+ axiom_node_t *signature_node,
+ axiom_node_t *signed_info_node,
+ oxs_sign_ctx_t *sign_ctx)
{
axis2_char_t *signature_val = NULL;
axis2_char_t *serialized_signed_info = NULL;
@@ -256,8 +292,8 @@
doc = axiom_node_get_document(signed_info_node, env);
/*oxs_c14n_apply(env, doc, AXIS2_FALSE, &c14nized, AXIS2_TRUE, NULL, signed_info_node); */
- oxs_c14n_apply_algo(env, doc, &c14nized, NULL, signed_info_node, c14n_algo);
- AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[oxs][xml_sig] C14N (sig)= %s ", c14nized );
+ oxs_c14n_apply_algo(env, doc, &c14nized, NULL, signed_info_node, c14n_algo);
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[oxs][xml_sig] C14N (sig)= %s ", c14nized);
/*Then serialize <SignedInfo>*/
serialized_signed_info = c14nized; /*axiom_node_to_string(signed_info_node, env);*/
@@ -266,17 +302,19 @@
input_buf = oxs_buffer_create(env);
output_buf = oxs_buffer_create(env);
- oxs_buffer_populate(input_buf, env, (unsigned char *)serialized_signed_info, axutil_strlen(serialized_signed_info));
+ oxs_buffer_populate(input_buf, env, (unsigned char *)serialized_signed_info, axutil_strlen(
+ serialized_signed_info));
/*Then sign... NOTE: The signature process includes making the digest. e.g. rsa-sha1 => RSA(SHA-1(contents))*/
status = oxs_sig_sign(env, sign_ctx, input_buf, output_buf);
signature_val = (axis2_char_t*)oxs_buffer_get_data(output_buf, env);
/*Construct <SignatureValue>*/
- signature_val_node = oxs_token_build_signature_value_element(env, signature_node, signature_val);
+ signature_val_node
+ = oxs_token_build_signature_value_element(env, signature_node, signature_val);
/*Free*/
- AXIS2_FREE(env->allocator , c14nized);
+ AXIS2_FREE(env->allocator, c14nized);
c14nized = NULL;
oxs_buffer_free(input_buf, env);
input_buf = NULL;
@@ -288,10 +326,11 @@
/*Public functions*/
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_sig_sign(const axutil_env_t *env,
- oxs_sign_ctx_t *sign_ctx,
- axiom_node_t *parent,
- axiom_node_t **sig_node)
+oxs_xml_sig_sign(
+ const axutil_env_t *env,
+ oxs_sign_ctx_t *sign_ctx,
+ axiom_node_t *parent,
+ axiom_node_t **sig_node)
{
axiom_node_t *signed_info_node = NULL;
axiom_node_t *signature_node = NULL;
@@ -302,7 +341,7 @@
axis2_char_t *sig_id = NULL;
axutil_array_list_t *sign_parts = NULL;
axis2_status_t status = AXIS2_FAILURE;
- int i=0;
+ int i = 0;
/*Construct the <Signature> element*/
sig_id = oxs_util_generate_id(env, OXS_SIG_ID);
@@ -323,11 +362,12 @@
signature_mtd_node = oxs_token_build_signature_method_element(env, signed_info_node, sign_algo);
/*Look for signature parts*/
- sign_parts = oxs_sign_ctx_get_sign_parts(sign_ctx , env);
+ sign_parts = oxs_sign_ctx_get_sign_parts(sign_ctx, env);
/*For each and every signature part in sig ctx,*/
- for (i = 0; i < axutil_array_list_size(sign_parts, env); i++){
- oxs_sign_part_t *sign_part = NULL;
+ for(i = 0; i < axutil_array_list_size(sign_parts, env); i++)
+ {
+ oxs_sign_part_t *sign_part = NULL;
/*Get ith sign_part*/
sign_part = (oxs_sign_part_t*)axutil_array_list_get(sign_parts, env, i);
@@ -340,7 +380,7 @@
}
/*At this point we have a complete <SignedInfo> node. Now we need to sign it*/
status = oxs_xml_sig_sign_signed_info(env, signature_node, signed_info_node, sign_ctx);
- /*sig_id = axiom_node_to_string(parent, env);*/
+ /*sig_id = axiom_node_to_string(parent, env);*/
*sig_node = signature_node;
return status;
}
@@ -349,135 +389,142 @@
/*Populates a sign_part according to the <ds:Reference> node*/
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_sig_process_ref_node(const axutil_env_t *env,
- oxs_sign_part_t *sign_part,
- axiom_node_t *ref_node,
- axiom_node_t *scope_node)
+oxs_xml_sig_process_ref_node(
+ const axutil_env_t *env,
+ oxs_sign_part_t *sign_part,
+ axiom_node_t *ref_node,
+ axiom_node_t *scope_node)
{
axis2_char_t *ref_id = NULL;
axis2_char_t *ref_id2 = NULL;
axis2_char_t *child_node_name = NULL;
axiom_node_t *reffed_node = NULL;
axiom_node_t *child_node = NULL, *cn = NULL;
-
- axis2_char_t *id_name = NULL;
- axiom_namespace_t *ns = NULL;
- axis2_char_t *ns_uri = NULL;
- axiom_attribute_t *attr = NULL;
- axutil_hash_t *attr_hash = NULL;
- axutil_hash_index_t *hi = NULL;
- axiom_element_t *element = NULL, *ce = NULL;
- axiom_child_element_iterator_t *ci = NULL;
- ref_id = oxs_token_get_ds_reference(env, ref_node);
+
+ axis2_char_t *id_name = NULL;
+ axiom_namespace_t *ns = NULL;
+ axis2_char_t *ns_uri = NULL;
+ axiom_attribute_t *attr = NULL;
+ axutil_hash_t *attr_hash = NULL;
+ axutil_hash_index_t *hi = NULL;
+ axiom_element_t *element = NULL, *ce = NULL;
+ axiom_child_element_iterator_t *ci = NULL;
+ ref_id = oxs_token_get_ds_reference(env, ref_node);
oxs_sign_part_set_id(sign_part, env, ref_id);
-
+
/*Remove the # from the id*/
- ref_id2 = axutil_string_substring_starting_at(axutil_strdup(env, ref_id), 1);
- /*Look for the attribute with the Reference URI value*/
- if(scope_node)
- {
- element = axiom_node_get_data_element(scope_node, env);
- if(element)
- attr_hash = axiom_element_get_all_attributes(element, env);
-
- if (attr_hash)
- {
- for (hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi))
- {
- void *v = NULL;
- axutil_hash_this(hi, NULL, NULL, &v);
- if (v)
- {
- axis2_char_t *attr_val = NULL;
- axiom_attribute_t *attribute = (axiom_attribute_t*)v;
- attr_val = axiom_attribute_get_value(attribute, env);
- if(!axutil_strcmp(attr_val, ref_id2))
- {
- attr = attribute;
- break;
- }
- }
- }
- }
- }
- /* if we cannot find the Id in the scope node proceed to childs*/
- if (!attr)
- {
- element = axiom_node_get_data_element(scope_node, env);
- if (element)
- {
- ci = axiom_element_get_child_elements(element, env, scope_node);
- if (ci)
- {
- while (AXIS2_TRUE == axiom_child_element_iterator_has_next(ci, env))
- {
- cn = axiom_child_element_iterator_next(ci, env);
- ce = axiom_node_get_data_element(cn, env);
- if(ce)
- attr_hash = axiom_element_get_all_attributes(ce, env);
-
- if (attr_hash)
- {
- for (hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi))
- {
- void *v = NULL;
- axutil_hash_this(hi, NULL, NULL, &v);
- if (v)
- {
- axis2_char_t *attr_val = NULL;
- axiom_attribute_t *attribute = (axiom_attribute_t*)v;
- attr_val = axiom_attribute_get_value(attribute, env);
- if(!axutil_strcmp(attr_val, ref_id2))
- {
- attr = attribute;
- if (env)
- AXIS2_FREE(env->allocator, hi);
- break;
- }
- }
- }
- }
- }
- }
- }
- }
-
- if(attr)
- {
- id_name = axiom_attribute_get_localname(attr, env);
- ns = axiom_attribute_get_namespace(attr, env);
- if(ns)
- ns_uri = axiom_namespace_get_uri(ns, env);
- else
- ns_uri = "";
- reffed_node = oxs_axiom_get_node_by_id(env, scope_node, id_name, ref_id2, ns_uri);
- }
- else
- {
- reffed_node = oxs_axiom_get_node_by_id(env, scope_node, "Id", ref_id2, OXS_WSU_XMLNS );
+ ref_id2 = axutil_string_substring_starting_at(axutil_strdup(env, ref_id), 1);
+ /*Look for the attribute with the Reference URI value*/
+ if(scope_node)
+ {
+ element = axiom_node_get_data_element(scope_node, env);
+ if(element)
+ attr_hash = axiom_element_get_all_attributes(element, env);
+
+ if(attr_hash)
+ {
+ for(hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env, hi))
+ {
+ void *v = NULL;
+ axutil_hash_this(hi, NULL, NULL, &v);
+ if(v)
+ {
+ axis2_char_t *attr_val = NULL;
+ axiom_attribute_t *attribute = (axiom_attribute_t*)v;
+ attr_val = axiom_attribute_get_value(attribute, env);
+ if(!axutil_strcmp(attr_val, ref_id2))
+ {
+ attr = attribute;
+ break;
+ }
+ }
+ }
+ }
+ }
+ /* if we cannot find the Id in the scope node proceed to childs*/
+ if(!attr)
+ {
+ element = axiom_node_get_data_element(scope_node, env);
+ if(element)
+ {
+ ci = axiom_element_get_child_elements(element, env, scope_node);
+ if(ci)
+ {
+ while(AXIS2_TRUE == axiom_child_element_iterator_has_next(ci, env))
+ {
+ cn = axiom_child_element_iterator_next(ci, env);
+ ce = axiom_node_get_data_element(cn, env);
+ if(ce)
+ attr_hash = axiom_element_get_all_attributes(ce, env);
+
+ if(attr_hash)
+ {
+ for(hi = axutil_hash_first(attr_hash, env); hi; hi = axutil_hash_next(env,
+ hi))
+ {
+ void *v = NULL;
+ axutil_hash_this(hi, NULL, NULL, &v);
+ if(v)
+ {
+ axis2_char_t *attr_val = NULL;
+ axiom_attribute_t *attribute = (axiom_attribute_t*)v;
+ attr_val = axiom_attribute_get_value(attribute, env);
+ if(!axutil_strcmp(attr_val, ref_id2))
+ {
+ attr = attribute;
+ if(env)
+ AXIS2_FREE(env->allocator, hi);
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if(attr)
+ {
+ id_name = axiom_attribute_get_localname(attr, env);
+ ns = axiom_attribute_get_namespace(attr, env);
+ if(ns)
+ ns_uri = axiom_namespace_get_uri(ns, env);
+ else
+ ns_uri = "";
+ reffed_node = oxs_axiom_get_node_by_id(env, scope_node, id_name, ref_id2, ns_uri);
+ }
+ else
+ {
+ reffed_node = oxs_axiom_get_node_by_id(env, scope_node, "Id", ref_id2, OXS_WSU_XMLNS);
/*for endorsing, we have to check "Id", not "wsu:Id"*/
if(!reffed_node)
{
- reffed_node = oxs_axiom_get_node_by_id(env, scope_node, "Id", ref_id2, NULL );
- }
- }
+ reffed_node = oxs_axiom_get_node_by_id(env, scope_node, "Id", ref_id2, NULL);
+ }
+ }
/*Find the node refered by this ref_id2 and set to the sign part*/
-
- if(reffed_node){
+
+ if(reffed_node)
+ {
oxs_sign_part_set_node(sign_part, env, reffed_node);
- }else{
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Cannot find node with Id=%s ", ref_id2 );
- AXIS2_FREE(env->allocator, ref_id2);
- ref_id2 = NULL;
+ }
+ else
+ {
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+ "Cannot find node with Id=%s ", ref_id2);
+ AXIS2_FREE(env->allocator, ref_id2);
+ ref_id2 = NULL;
return AXIS2_FAILURE; /*No such node. Its an error*/
}
- AXIS2_FREE(env->allocator, ref_id2);
- ref_id2 = NULL;
+ AXIS2_FREE(env->allocator, ref_id2);
+ ref_id2 = NULL;
/*First child is optional Transforms element*/
child_node = axiom_node_get_first_element(ref_node, env);
child_node_name = axiom_util_get_localname(child_node, env);
- if(0 == axutil_strcmp(child_node_name, OXS_NODE_TRANSFORMS)){
+ if(0 == axutil_strcmp(child_node_name, OXS_NODE_TRANSFORMS))
+ {
/*Transforms found*/
axiom_node_t *tr_node = NULL;
axutil_array_list_t *tr_list = NULL;
@@ -491,30 +538,35 @@
axis2_char_t *node_name = NULL;
node_name = axiom_util_get_localname(tr_node, env);
- if( 0 == axutil_strcmp(OXS_NODE_TRANSFORM, node_name)){
+ if(0 == axutil_strcmp(OXS_NODE_TRANSFORM, node_name))
+ {
axis2_char_t *tr_id = NULL;
oxs_transform_t *tr = NULL;
tr_id = oxs_token_get_transform(env, tr_node);
/*Get the transform given the id*/
tr = oxs_transforms_factory_produce_transform(env, tr_id);
- if(!tr) {
+ if(!tr)
+ {
/*The transform not supported*/
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,"Cannot produce the transform for %s", tr_id);
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,
+ "Cannot produce the transform for %s", tr_id);
return AXIS2_FAILURE;
}
/*Add the transform to the list*/
axutil_array_list_add(tr_list, env, tr);
- }else{
+ }
+ else
+ {
/*<ds:Transforms> cant have any other element*/
/*NOTE: Removed this check for interop testing*/
/*oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_TRANSFORM_FAILED,"<ds:Transforms> cannot have node %s ", node_name );
- return AXIS2_FAILURE;*/
+ return AXIS2_FAILURE;*/
}
/*Set the next node to be processed*/
tr_node = axiom_node_get_next_sibling(tr_node, env);
/*axiom_util_get_next_sibling_element(axiom_node_get_data_element(tr_node, env), env,
- tr_node, &tr_node);*/
+ tr_node, &tr_node);*/
}/*eof while*/
/*Set transforms for this signature part*/
oxs_sign_part_set_transforms(sign_part, env, tr_list);
@@ -522,14 +574,17 @@
/*At the end, set the next node as the child node*/
/*child_node = axiom_node_get_next_sibling(child_node, env);*/
axiom_util_get_next_sibling_element(axiom_node_get_data_element(child_node, env), env,
- child_node, &child_node);
- }else{
+ child_node, &child_node);
+ }
+ else
+ {
/*There are no transforms for this sign part*/
}
/* Process mandatory ds:DigestMethod*/
child_node_name = axiom_util_get_localname(child_node, env);
- if(0 == axutil_strcmp(child_node_name, OXS_NODE_DIGEST_METHOD)){
+ if(0 == axutil_strcmp(child_node_name, OXS_NODE_DIGEST_METHOD))
+ {
axis2_char_t *digest_mtd = NULL;
/*ds:DigestMethod found*/
digest_mtd = oxs_token_get_digest_method(env, child_node);
@@ -538,21 +593,28 @@
/*At the end, set the next node as the child node*/
/*child_node = axiom_node_get_next_sibling(child_node, env);*/
axiom_util_get_next_sibling_element(axiom_node_get_data_element(child_node, env), env,
- child_node, &child_node);
- }else{
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Cannot find <ds:DigestMethod> " );
+ child_node, &child_node);
+ }
+ else
+ {
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+ "Cannot find <ds:DigestMethod> ");
return AXIS2_FAILURE;
}
/* Process mandatory ds:DigestValue*/
child_node_name = axiom_util_get_localname(child_node, env);
- if(0 == axutil_strcmp(child_node_name, OXS_NODE_DIGEST_VALUE)){
+ if(0 == axutil_strcmp(child_node_name, OXS_NODE_DIGEST_VALUE))
+ {
/*ds:DigestValue found*/
axis2_char_t *digest_val = NULL;
digest_val = oxs_token_get_digest_value(env, child_node);
oxs_sign_part_set_digest_val(sign_part, env, digest_val);
- }else{
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Cannot find <ds:DigestValue> " );
+ }
+ else
+ {
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+ "Cannot find <ds:DigestValue> ");
return AXIS2_FAILURE;
}
@@ -570,10 +632,11 @@
* 3.3. Transforms*/
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_sig_process_signature_node(const axutil_env_t *env,
- oxs_sign_ctx_t *sign_ctx,
- axiom_node_t *signature_node,
- axiom_node_t *scope_node)
+oxs_xml_sig_process_signature_node(
+ const axutil_env_t *env,
+ oxs_sign_ctx_t *sign_ctx,
+ axiom_node_t *signature_node,
+ axiom_node_t *scope_node)
{
axiom_node_t *cur_node = NULL;
axiom_node_t *signed_info_node = NULL;
@@ -582,57 +645,69 @@
axutil_array_list_t *sign_part_list = NULL;
signed_info_node = oxs_axiom_get_first_child_node_by_name(env, signature_node,
- OXS_NODE_SIGNEDINFO, OXS_DSIG_NS, OXS_DS );
+ OXS_NODE_SIGNEDINFO, OXS_DSIG_NS, OXS_DS);
/*signed_info_node = oxs_axiom_get_first_child_node_by_name(env, signature_node,
- OXS_NODE_SIGNEDINFO, NULL,NULL);*/
+ OXS_NODE_SIGNEDINFO, NULL,NULL);*/
- if(!signed_info_node){
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Cannot find <ds:SignedInfo> " );
+ if(!signed_info_node)
+ {
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+ "Cannot find <ds:SignedInfo> ");
return AXIS2_FAILURE;
}
/*Create the list for sign parts*/
- sign_part_list = axutil_array_list_create(env,5);
+ sign_part_list = axutil_array_list_create(env, 5);
/*Process signed info element*/
cur_node = axiom_node_get_first_element(signed_info_node, env);
/*Iterate thru children of <SignedInfo>*/
- while(cur_node){
- axis2_char_t *localname = NULL;
+ while(cur_node)
+ {
+ axis2_char_t *localname = NULL;
- localname = axiom_util_get_localname(cur_node, env);
+ localname = axiom_util_get_localname(cur_node, env);
- if(0 == axutil_strcmp(localname, OXS_NODE_CANONICALIZATION_METHOD)){
+ if(0 == axutil_strcmp(localname, OXS_NODE_CANONICALIZATION_METHOD))
+ {
axis2_char_t *c14n_mtd = NULL;
c14n_mtd = oxs_token_get_c14n_method(env, cur_node);
oxs_sign_ctx_set_c14n_mtd(sign_ctx, env, c14n_mtd);
- }else if(0 == axutil_strcmp(localname, OXS_NODE_SIGNATURE_METHOD)){
+ }
+ else if(0 == axutil_strcmp(localname, OXS_NODE_SIGNATURE_METHOD))
+ {
axis2_char_t *sig_mtd = NULL;
sig_mtd = oxs_token_get_signature_method(env, cur_node);
oxs_sign_ctx_set_sign_mtd_algo(sign_ctx, env, sig_mtd);
- }else if(0 == axutil_strcmp(localname, OXS_NODE_REFERENCE)){
+ }
+ else if(0 == axutil_strcmp(localname, OXS_NODE_REFERENCE))
+ {
oxs_sign_part_t *sign_part = NULL;
/* There might be multiple references.
* For each create a sign_part and add to sign_part_list in the sign_ctx*/
sign_part = oxs_sign_part_create(env);
status = oxs_xml_sig_process_ref_node(env, sign_part, cur_node, scope_node);
- if(status == AXIS2_FAILURE){
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"<ds:Reference> node processing failed " );
+ if(status == AXIS2_FAILURE)
+ {
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+ "<ds:Reference> node processing failed ");
return AXIS2_FAILURE;
}
/*Now we have a new sign_part. Add it to the list.*/
axutil_array_list_add(sign_part_list, env, sign_part);
- }else{
+ }
+ else
+ {
/*We do not process*/
}
cur_node = axiom_node_get_next_sibling(cur_node, env);
/*axiom_util_get_next_sibling_element(axiom_node_get_data_element(cur_node, env), env,
- cur_node, &cur_node);*/
+ cur_node, &cur_node);*/
}
oxs_sign_ctx_set_sign_parts(sign_ctx, env, sign_part_list);
@@ -640,22 +715,25 @@
/*The very next child of SignedInfo Should be the ds:SignatureValue*/
/*sig_val_node = axiom_node_get_next_sibling(signed_info_node, env);*/
axiom_util_get_next_sibling_element(axiom_node_get_data_element(signed_info_node, env), env,
- signed_info_node, &sig_val_node);
- if(0 == axutil_strcmp( OXS_NODE_SIGNATURE_VALUE, axiom_util_get_localname(sig_val_node, env))){
+ signed_info_node, &sig_val_node);
+ if(0 == axutil_strcmp(OXS_NODE_SIGNATURE_VALUE, axiom_util_get_localname(sig_val_node, env)))
+ {
axis2_char_t *sig_val = NULL;
axis2_char_t *newline_removed = NULL;
sig_val = oxs_token_get_signature_value(env, sig_val_node);
if(!sig_val)
{
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Cannot find signature value. " );
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+ "Cannot find signature value. ");
return AXIS2_FAILURE;
}
/*We now remove \n in this text.Otherwise verifications failed.*/
- newline_removed = oxs_util_get_newline_removed_string(env,sig_val);
+ newline_removed = oxs_util_get_newline_removed_string(env, sig_val);
if(!newline_removed)
{
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Cannot Remove new lines. " );
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+ "Cannot Remove new lines. ");
return AXIS2_FAILURE;
}
oxs_sign_ctx_set_sig_val(sign_ctx, env, newline_removed);
@@ -663,9 +741,12 @@
/*We can free newline_removed string as sign_ctx duplicates it*/
AXIS2_FREE(env->allocator, newline_removed);
newline_removed = NULL;
- }else{
+ }
+ else
+ {
/*Error the node should be the ds:SignatureValue*/
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Cannot find <ds:SignatureValue> " );
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+ "Cannot find <ds:SignatureValue> ");
return AXIS2_FAILURE;
}
@@ -673,8 +754,9 @@
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_sig_verify_sign_part(const axutil_env_t *env,
- oxs_sign_part_t *sign_part)
+oxs_xml_sig_verify_sign_part(
+ const axutil_env_t *env,
+ oxs_sign_part_t *sign_part)
{
axis2_char_t *id = NULL;
axis2_char_t *digest_mtd = NULL;
@@ -684,24 +766,28 @@
axutil_array_list_t *transforms = NULL;
axis2_status_t status = AXIS2_FAILURE;
- id = oxs_sign_part_get_id(sign_part, env);
- digest_mtd = oxs_sign_part_get_digest_mtd(sign_part, env);
- digest_val = oxs_sign_part_get_digest_val(sign_part, env);
- node = oxs_sign_part_get_node(sign_part, env);
- transforms = oxs_sign_part_get_transforms(sign_part, env);
+ id = oxs_sign_part_get_id(sign_part, env);
+ digest_mtd = oxs_sign_part_get_digest_mtd(sign_part, env);
+ digest_val = oxs_sign_part_get_digest_val(sign_part, env);
+ node = oxs_sign_part_get_node(sign_part, env);
+ transforms = oxs_sign_part_get_transforms(sign_part, env);
- AXIS2_LOG_INFO(env->log, "[oxs][xml_sig] Verifying signature part %s ", id );
+ AXIS2_LOG_INFO(env->log, "[oxs][xml_sig] Verifying signature part %s ", id);
/*Do transforms to the node*/
new_digest = oxs_xml_sig_transform_n_digest(env, node, transforms, digest_mtd);
/*Compare values*/
- if(0 == axutil_strcmp(new_digest, digest_val)){
- AXIS2_LOG_INFO(env->log, "[oxs][xml_sig] Digest verification success for node Id= %s ", id );
+ if(0 == axutil_strcmp(new_digest, digest_val))
+ {
+ AXIS2_LOG_INFO(env->log, "[oxs][xml_sig] Digest verification success for node Id= %s ", id);
status = AXIS2_SUCCESS;
- }else{
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Digest verification failed for node Id= %s ", id );
- status = AXIS2_FAILURE;
+ }
+ else
+ {
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+ "Digest verification failed for node Id= %s ", id);
+ status = AXIS2_FAILURE;
}
/*FREE*/
@@ -712,23 +798,26 @@
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_sig_verify_digests(const axutil_env_t *env,
- oxs_sign_ctx_t *sign_ctx)
+oxs_xml_sig_verify_digests(
+ const axutil_env_t *env,
+ oxs_sign_ctx_t *sign_ctx)
{
axis2_status_t status = AXIS2_FAILURE;
axutil_array_list_t *sign_parts = NULL;
- int i = 0 ;
+ int i = 0;
/*Get the sign_part list*/
- sign_parts = oxs_sign_ctx_get_sign_parts(sign_ctx, env);
+ sign_parts = oxs_sign_ctx_get_sign_parts(sign_ctx, env);
/*For each and every signature part in sig ctx,*/
- for (i = 0; i < axutil_array_list_size(sign_parts, env); i++){
- oxs_sign_part_t *sign_part = NULL;
+ for(i = 0; i < axutil_array_list_size(sign_parts, env); i++)
+ {
+ oxs_sign_part_t *sign_part = NULL;
/*Get ith sign_part*/
sign_part = (oxs_sign_part_t*)axutil_array_list_get(sign_parts, env, i);
status = oxs_xml_sig_verify_sign_part(env, sign_part);
- if(AXIS2_FAILURE == status){
+ if(AXIS2_FAILURE == status)
+ {
return AXIS2_FAILURE;
}
}
@@ -738,10 +827,11 @@
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-oxs_xml_sig_verify(const axutil_env_t *env,
- oxs_sign_ctx_t *sign_ctx,
- axiom_node_t *signature_node,
- axiom_node_t *scope_node)
+oxs_xml_sig_verify(
+ const axutil_env_t *env,
+ oxs_sign_ctx_t *sign_ctx,
+ axiom_node_t *signature_node,
+ axiom_node_t *scope_node)
{
axis2_status_t status = AXIS2_FAILURE;
axiom_node_t *signed_info_node = NULL;
@@ -749,16 +839,17 @@
axis2_char_t *c14n_mtd = NULL;
axis2_char_t *content = NULL;
axis2_char_t *signature_val = NULL;
- axis2_char_t *signed_info_node_value = NULL;
/*Set operation to verify*/
oxs_sign_ctx_set_operation(sign_ctx, env, OXS_SIGN_OPERATION_VERIFY);
/*Populate the sign_ctx by inspecting the ds:Signature node*/
status = oxs_xml_sig_process_signature_node(env, sign_ctx, signature_node, scope_node);
- if(status != AXIS2_SUCCESS){
+ if(status != AXIS2_SUCCESS)
+ {
/*Something went wrong while processing the Signature node!!! :(*/
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"<ds:Signature> node processing failed " );
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+ "<ds:Signature> node processing failed ");
return AXIS2_FAILURE;
}
@@ -769,10 +860,13 @@
/*Verify the integrity of the signed parts by comparing the digest values of each and every reference.*/
status = oxs_xml_sig_verify_digests(env, sign_ctx);
- if(AXIS2_FAILURE == status){
+ if(AXIS2_FAILURE == status)
+ {
return AXIS2_FAILURE;
- }else{
- AXIS2_LOG_INFO(env->log, "[oxs][xml_sig] Digests verification SUCCESS " );
+ }
+ else
+ {
+ AXIS2_LOG_INFO(env->log, "[oxs][xml_sig] Digests verification SUCCESS ");
}
/*At this point we have compared the digest. Next step is to compare the Signature value */
@@ -781,36 +875,41 @@
/*Then we apply the C14N for the ds:SignedInfo*/
signed_info_node = oxs_axiom_get_first_child_node_by_name(env, signature_node,
- OXS_NODE_SIGNEDINFO, OXS_DSIG_NS, OXS_DS );
+ OXS_NODE_SIGNEDINFO, OXS_DSIG_NS, OXS_DS);
/*signed_info_node = oxs_axiom_get_first_child_node_by_name(env, signature_node,
- OXS_NODE_SIGNEDINFO, NULL,NULL );*/
+ OXS_NODE_SIGNEDINFO, NULL,NULL );*/
c14n_mtd = oxs_sign_ctx_get_c14n_mtd(sign_ctx, env);
doc = axiom_node_get_document(signed_info_node, env);
- signed_info_node_value = axiom_node_to_string(signed_info_node, env);
- AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[oxs][xml_sig] C14N (verif1)= %s ", signed_info_node_value );
- AXIS2_FREE(env->allocator, signed_info_node_value);
- signed_info_node_value = NULL;
- /* oxs_c14n_apply(env, doc, AXIS2_FALSE, &content, AXIS2_TRUE, NULL, signed_info_node);*/
+ IF_AXIS2_LOG_DEBUG_ENABLED(env->log)
+ {
+ axis2_char_t *node_value = NULL;
+ node_value = axiom_node_to_string(signed_info_node, env);
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart] C14N (verif1)= %s ", node_value);
+ AXIS2_FREE(env->allocator, node_value);
+ }
oxs_c14n_apply_algo(env, doc, &content, NULL, signed_info_node, c14n_mtd);
- AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[oxs][xml_sig] C14N (verif2)=\n\n%s\n\n", content );
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[oxs][xml_sig] C14N (verif2)=\n\n%s\n\n", content);
/*In the final step we Verify*/
- status = oxs_sig_verify(env, sign_ctx, content , signature_val);
+ status = oxs_sig_verify(env, sign_ctx, content, signature_val);
AXIS2_FREE(env->allocator, content);
content = NULL;
- if(AXIS2_FAILURE == status){
- oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,"Signature is not valid " );
+ if(AXIS2_FAILURE == status)
+ {
+ oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_SIG_VERIFICATION_FAILED,
+ "Signature is not valid ");
return AXIS2_FAILURE;
- }else{
+ }
+ else
+ {
return AXIS2_SUCCESS;
}
-
}