OneTeam/oc-facho
16
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

se adicionan archivos faltantes

Browse Source 
FossilOrigin-Name: 85fd66cb6f56b56c71826cb1cc02afa625c277c1f12dc92cfbc741b3808cf646
This commit is contained in:
bit4bit
2021-12-10 14:31:00 +00:00
parent 23d6f668bf
commit d36259d121
6 changed files with 319 additions and 299 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
experimental/facho-signer/xades/Makefile
View File

@@ -2,6 +2,6 @@
CC=gcc
test: xmlsec1/errors.c xmlsec1/xmltree.c xades.c xades_test.c
$(CC) -o $@ -Wall $(shell pkg-config libxml-2.0 --cflags --libs) $(shell pkg-config xmlsec1 --cflags --libs) $^
test: xmlsec1/errors.c xmlsec1/xmltree.c templates.c xades_test.c
$(CC) -o $@ -Wall -Werror -std=gnu11 $(shell pkg-config libxml-2.0 --cflags --libs) $(shell pkg-config xmlsec1 --cflags --libs) $^
./test

326
experimental/facho-signer/xades/xades.c
View File

@@ -1,306 +1,58 @@
#include <time.h>
#include "xades.h"
#define xmlXadesAssert2(p, ret) \
xmlSecAssert2(p, ret)
#define xmlXadesNodeNotFoundError(errorFunction, startNode, targetNodeName, errorObject) \
xmlSecNodeNotFoundError(errorFunction, startNode, targetNodeName, errorObject)
#define xmlXadesXmlError2(errorFunction, errorObject, msg, param) \
xmlSecXmlError2(errorFunction, errorObject, msg, param)
#define xmlXadesErrorsSafeString(msg) \
xmlSecErrorsSafeString(msg)
#define xmlXadesInternalError(errorFunction, errorObject) \
xmlSecInternalError(errorFunction, errorObject)
#define xmlXadesNodeAlreadyPresentError(parent, nodeName, errObject) \
xmlSecNodeAlreadyPresentError(parent, nodeName, errObject)
xmlNodePtr
xmlXadesTmplQualifyingPropertiesCreateNsPref(xmlDocPtr doc, const xmlChar* id, const xmlChar* nsPrefix) {
xmlNodePtr qualifyingPropertiesNode;
int
xmlFachoAppSign(xmlDocPtr doc,
xmlSecTransformId hashMethodId) {
xmlXadesAssert2(doc != NULL, NULL);
xmlNodePtr cur;
xmlNsPtr ns;
// crear nodo
qualifyingPropertiesNode = xmlNewDocNode(doc, NULL, xmlXadesNodeQualifyingProperties, NULL);
if (qualifyingPropertiesNode == NULL) {
xmlXadesXmlError2("xmlNewDocNode", NULL, "node=%s", xmlXadesErrorsSafeString(xmlXadesNodeQualifyingProperties));
return(NULL);
}
// crear namespace y asignar
ns = xmlNewNs(qualifyingPropertiesNode, xmlXadesDSigNs, nsPrefix);
if (ns == NULL) {
xmlXadesXmlError2("xmlNewNs", NULL,
"ns=%s", xmlXadesErrorsSafeString(xmlXadesDSigNs));
xmlFreeNode(qualifyingPropertiesNode);
return(NULL);
}
xmlSetNs(qualifyingPropertiesNode, ns);
if (id != NULL) {
xmlSetProp(qualifyingPropertiesNode, BAD_CAST "id", id);
}
// add SignedProperties
cur = xmlSecAddChild(qualifyingPropertiesNode, xmlXadesNodeSignedProperties, xmlXadesDSigNs);
if (cur == NULL) {
xmlXadesInternalError("xmlSecAddChild(xmlXadesNodeSignedProperties)", NULL);
xmlFreeNode(qualifyingPropertiesNode);
return(NULL);
}
return (qualifyingPropertiesNode);
}
xmlNodePtr
xmlXadesTmplAddSignedSignatureProperties(xmlNodePtr parentNode, const xmlChar* id, struct tm* signingTime) {
xmlNodePtr cur;
xmlNodePtr node;
xmlNodePtr signedPropertiesNode;
xmlXadesAssert2(parentNode != NULL, NULL);
xmlNodePtr signedSignaturePropertiesNode;
xmlNodePtr signaturePolicyIdentifierNode;
xmlNodePtr signaturePolicyIdNode;
xmlChar* signedPropertiesId = BAD_CAST "ref1-signedprops";
time_t now = time(NULL);
signedPropertiesNode = xmlSecFindChild(parentNode, xmlXadesNodeSignedProperties, xmlXadesDSigNs);
if (signedPropertiesNode == NULL) {
xmlXadesNodeNotFoundError("xmlSecFindChild", parentNode,
xmlXadesNodeSignedProperties, NULL);
return(NULL);
}
// add SignedSignatureProperties
node = xmlSecAddChild(signedPropertiesNode, xmlXadesNodeSignedSignatureProperties, xmlXadesDSigNs);
if (node == NULL) {
xmlXadesInternalError("xmlSecAddChild(xmlXadesNodeSignedSignatureProperties)", NULL);
return(NULL);
}
if (id != NULL) {
xmlSetProp(node, BAD_CAST "id", id);
}
// add SignigTime
cur = xmlSecAddChild(node, xmlXadesNodeSigningTime, xmlXadesDSigNs);
cur = xmlXadesTmplQualifyingPropertiesCreateNsPref(doc, "qualify-ref1", BAD_CAST "ds");
if (cur == NULL) {
xmlXadesInternalError("xmlSecAddChild(xmlXadesNodeSigningTime)", NULL);
xmlFreeNode(node);
return(NULL);
return(-1);
}
{
int ret;
char strtime[200];
cur = xmlXadesTmplAddSignedProperties(cur, signedPropertiesId);
if (cur == NULL) {
return(-1);
}
if (strftime(strtime, sizeof(strtime), "%Y-%m-%dT%T", signingTime) == 0) {
xmlXadesInternalError("strftime", NULL);
xmlFreeNode(cur);
xmlFreeNode(node);
return(NULL);
}
ret = xmlSecNodeEncodeAndSetContent(cur, BAD_CAST strtime);
if (ret < 0) {
xmlXadesInternalError("xmlSecNodeEncodeAndSetContent", NULL);
xmlFreeNode(cur);
xmlFreeNode(node);
return(NULL);
}
signedSignaturePropertiesNode = xmlXadesTmplAddSignedSignatureProperties(cur, now);
if (signedSignaturePropertiesNode == NULL) {
return(-1);
}
// addSigningCertificate
cur = xmlSecAddChild(node, xmlXadesNodeSigningCertificate, xmlXadesDSigNs);
// addSignaturePolicyIdentifier
signaturePolicyIdNode = xmlXadesAddChildRecursiveNs(signedSignaturePropertiesNode, BAD_CAST "SignaturePolicyIdentifier/SignaturePolicyId", xmlXadesDSigNs)
if (signaturePolicyIdNode == NULL) {
return(-1);
}
cur = xmlXadesTmplAddSigPolicyId(signaturePolicyIdNode, identifier, description, hashMethodId);
if (cur == NULL) {
xmlXadesInternalError("xmlSecAddChild(xmlXadesNodeSigningCertificate)", NULL);
xmlFreeNode(node);
return(NULL);
return(-1);
}
return(node);
}
xmlNodePtr
xmlXadesTmplAddSigningCertificate(xmlNodePtr signedSignaturePropertiesNode) {
xmlNodePtr node;
xmlXadesAssert2(signedSignaturePropertiesNode != NULL, NULL);
if (xmlSecFindChild(signedSignaturePropertiesNode, xmlXadesNodeSigningCertificate, xmlXadesDSigNs) != NULL) {
xmlXadesNodeAlreadyPresentError(signedSignaturePropertiesNode, xmlXadesNodeSigningCertificate, NULL);
return(NULL);
}
node = xmlSecAddChild(signedSignaturePropertiesNode, xmlXadesNodeSigningCertificate, xmlXadesDSigNs);
if (node == NULL) {
xmlXadesInternalError("xmlsecAddChild(xmlXadesNodeSigningCertificate)", NULL);
return(NULL);
}
return(node);
}
xmlNodePtr
xmlXadesTmplAddCert(xmlNodePtr parentNode) {
xmlNodePtr node;
xmlXadesAssert2(parentNode != NULL, NULL);
if (xmlSecFindChild(parentNode, xmlXadesNodeCertificate, xmlXadesDSigNs) != NULL) {
xmlXadesNodeAlreadyPresentError(parentNode, xmlXadesNodeCertificate, NULL);
return(NULL);
}
node = xmlSecAddChild(parentNode, xmlXadesNodeCertificate, xmlXadesDSigNs);
if (node == NULL) {
xmlXadesInternalError("xmlSecAddChild(xmlXadesNodeCertificate)", NULL);
return(NULL);
}
return(node);
}
xmlNodePtr
xmlXadesTmplAddSignaturePolicyIdentifierSignaturePolicyId(xmlNodePtr signedSignaturePropertiesNode) {
xmlNodePtr cur;
xmlXadesAssert2(signedSignaturePropertiesNode != NULL, NULL);
if (xmlSecFindChild(signedSignaturePropertiesNode, xmlXadesNodeSigningCertificate, xmlXadesDSigNs) != NULL) {
xmlXadesNodeAlreadyPresentError(signedSignaturePropertiesNode, xmlXadesNodeSigningCertificate, NULL);
return(NULL);
}
cur = xmlSecAddChild(signedSignaturePropertiesNode, xmlXadesNodeSignaturePolicyIdentifier, xmlXadesDSigNs);
// SignaturePolicyIdentifier/SignaturePolicyId/SigPolicyHash
cur = xmlXadesTmplAddSigPolicyHash(signaturePolicyIdNode);
if (cur == NULL) {
xmlXadesInternalError("xmlsecAddChild(xmlXadesNodeSignaturePolicyIdentifier)", NULL);
return(NULL);
return(-1);
}
cur = xmlSecAddChild(cur, xmlXadesNodeSignaturePolicyId, xmlXadesDSigNs);
cur = xmlXadesTmplAddDigest(cur, hashMethodId);
if (cur == NULL) {
xmlXadesInternalError("xmlsecAddChild(xmlXadesNodeSignaturePolicyId)", NULL);
return(NULL);
return(-1);
}
// addSignerRole
xmlXadesTmplAddSignerRole(signedSignaturePropertiesNode, BAD_CAST "supplier");
return(cur);
}
xmlNodePtr
xmlXadesTmplAddSigPolicyId(xmlNodePtr signaturePolicyId, const xmlChar* identifier, const xmlChar *description, xmlSecTransformId policyDigestMethodId) {
xmlNodePtr sigPolicyIdNode;
xmlNodePtr sigPolicyHashNode;
xmlNodePtr node;
int ret;
sigPolicyIdNode = xmlSecAddChild(signaturePolicyId, xmlXadesNodeSigPolicyId, xmlXadesDSigNs);
if (sigPolicyIdNode == NULL) {
xmlXadesInternalError("xmlSecAddChild(xmlXadesNodeSigPolicyId)", NULL);
return(NULL);
}
node = xmlSecAddChild(sigPolicyIdNode, xmlXadesNodeIdentifier, xmlXadesDSigNs);
if (node == NULL) {
xmlXadesInternalError("xmlSecAddChild(xmlXadesNodeIdentifier)", NULL);
xmlFreeNode(sigPolicyIdNode);
return(NULL);
}
ret = xmlSecNodeEncodeAndSetContent(node, identifier);
if (ret < 0) {
xmlXadesInternalError("xmlSecNodeEncodeAndSetContent", NULL);
xmlFreeNode(sigPolicyIdNode);
xmlFreeNode(node);
return(NULL);
}
node = xmlSecAddChild(sigPolicyIdNode, xmlXadesNodeDescription, xmlXadesDSigNs);
if (node == NULL) {
xmlXadesInternalError("xmlSecAddChild(xmlXadesNodeDescription)", NULL);
xmlFreeNode(sigPolicyIdNode);
return(NULL);
}
ret = xmlSecNodeEncodeAndSetContent(node, identifier);
if (ret < 0) {
xmlXadesInternalError("xmlSecNodeEncodeAndSetContent", NULL);
xmlFreeNode(sigPolicyIdNode);
xmlFreeNode(node);
return(NULL);
}
//add policyHash
sigPolicyHashNode = xmlSecAddChild(sigPolicyIdNode, xmlXadesNodeSigPolicyHash, xmlXadesDSigNs);
if (sigPolicyHashNode == NULL) {
xmlXadesInternalError("xmlSecAddChild(xmlXadesNodeSigPolicyHash)", NULL);
xmlFreeNode(sigPolicyIdNode);
return(NULL);
}
node = xmlSecAddChild(sigPolicyHashNode, xmlSecNodeDigestMethod, xmlXadesDSigNs);
if (sigPolicyHashNode == NULL) {
xmlXadesInternalError("xmlSecAddChild(xmlSecNodeDigestMethod)", NULL);
xmlUnlinkNode(sigPolicyHashNode);
xmlFreeNode(sigPolicyHashNode);
return(NULL);
}
if (xmlSetProp(node, xmlSecAttrAlgorithm, policyDigestMethodId->href) == NULL) {
xmlXadesXmlError2("xmlSetProp", NULL,
"name=%s", xmlXadesErrorsSafeString(xmlSecAttrAlgorithm));
xmlUnlinkNode(sigPolicyHashNode);
xmlFreeNode(sigPolicyHashNode);
return(node);
}
node = xmlSecAddChild(sigPolicyHashNode, xmlSecNodeDigestValue, xmlXadesDSigNs);
if (node == NULL) {
xmlXadesInternalError("xmlSecAddChild(xmlSecNodeDigestValue)", NULL);
xmlUnlinkNode(sigPolicyHashNode);
xmlFreeNode(sigPolicyHashNode);
return(NULL);
}
return(sigPolicyIdNode);
}
void
xmlXadesTmplAddSignerRole(xmlNodePtr signedSignaturePropertiesNode, const xmlChar* role) {
xmlNodePtr signerRoleNode;
xmlNodePtr claimedRolesNode;
xmlNodePtr claimedRoleNode;
int ret;
signerRoleNode = xmlSecAddChild(signedSignaturePropertiesNode, xmlXadesNodeSignerRole, xmlXadesDSigNs);
if (signerRoleNode == NULL) {
xmlXadesInternalError("xmlSecAddChild(xmlXadesNodeSignerRole)", NULL);
return(NULL);
}
claimedRolesNode = xmlSecAddChild(signerRoleNode, xmlXadesNodeClaimedRoles, xmlXadesDSigNs);
if (claimedRolesNode == NULL) {
xmlXadesInternalError("xmlSecAddChild(xmlXadesNodeClaimedRoles)", NULL);
xmlUnlinkNode(signerRoleNode);
xmlFreeNode(signerRoleNode);
return(NULL);
}
claimedRoleNode = xmlSecAddChild(claimedRolesNode, xmlXadesNodeClaimedRole, xmlXadesDSigNs);
if (claimedRoleNode == NULL) {
xmlXadesInternalError("xmlSecAddChild(xmlXadesNodeClaimedRole)", NULL);
xmlUnlinkNode(signerRoleNode);
xmlFreeNode(signerRoleNode);
return(NULL);
}
ret = xmlSecNodeEncodeAndSetContent(claimedRoleNode, role);
if (ret < 0) {
xmlXadesInternalError("xmlSecNodeEncodeAndSetContent", NULL);
xmlUnlinkNode(signerRoleNode);
xmlFreeNode(signerRoleNode);
return(NULL);
}
return;
cur = xmlSecTmplSignatureAddReference(xmlDocGetRootElement(doc),
hashMethodId,
signedPropertiesId,
NULL, NULL);
}

8
experimental/facho-signer/xades/xades.h
View File

@@ -32,14 +32,14 @@ xmlNodePtr
xmlXadesTmplQualifyingPropertiesCreateNsPref(xmlDocPtr doc, const xmlChar* id, const xmlChar* nsPrefix);
xmlNodePtr
xmlXadesTmplAddSignedSignatureProperties(xmlNodePtr parentNode, const xmlChar* id, struct tm* signingTime);
xmlNodePtr
xmlXadesTmplAddSigningCertificate(xmlNodePtr parentNode);
xmlNodePtr
xmlXadesTmplAddCert(xmlNodePtr signingCertificateNode);
xmlNodePtr
xmlXadesTmplAddSignaturePolicyIdentifierSignaturePolicyId(xmlNodePtr signedSignaturePropertiesNode);
xmlNodePtr
xmlXadesTmplAddSignedSignatureProperties(xmlNodePtr parentNode, struct tm* signingTime);
xmlNodePtr
xmlXadesAddChildRecursiveNs(xmlNodePtr parentNode, const xmlChar* path, const xmlChar* nsPrefix);
#endif //XADES_H

32
experimental/facho-signer/xades/xades_test.c
View File

@@ -6,7 +6,31 @@
#include "xades.h"
MU_TEST(test_xml_add_node_recursive) {
xmlDocPtr doc;
xmlNodePtr root;
xmlNodePtr child;
xmlChar* xmlbuff;
int xmlbuffsize;
doc = xmlNewDoc(BAD_CAST "1.0");
root = xmlNewNode(NULL, BAD_CAST "root");
xmlDocSetRootElement(doc, root);
child = xmlXadesAddChildRecursiveNs(root, BAD_CAST "A/B/C", NULL);
mu_check(child != NULL);
xmlDocDumpMemory(doc, &xmlbuff, &xmlbuffsize);
mu_assert_string_eq("<?xml version=\"1.0\"?>\n"
"<root>\n"
"<A>\n"
"<B>\n"
"<C/>\n"
"</B>\n"
"</A>\n"
"</root>\n"
, (char *)xmlbuff);
}
MU_TEST(test_qualifying_properties_layout) {
xmlDocPtr doc;
@@ -30,7 +54,7 @@ MU_TEST(test_qualifying_properties_layout) {
xmlDocSetRootElement(doc, root);
node = xmlXadesTmplQualifyingPropertiesCreateNsPref(doc, BAD_CAST "123", NULL);
xmlXadesTmplAddSignedSignatureProperties(node, NULL, &tm);
xmlXadesTmplAddSignedSignatureProperties(node, &tm);
mu_check(node != NULL);
xmlSecAddChildNode(root, node);
@@ -53,12 +77,8 @@ MU_TEST(test_qualifying_properties_layout) {
xmlFreeDoc(doc);
}
MU_TEST(test_check) {
mu_check(5 == 7);
}
MU_TEST_SUITE(test_suite) {
MU_RUN_TEST(test_check);
MU_RUN_TEST(test_xml_add_node_recursive);
MU_RUN_TEST(test_qualifying_properties_layout);
}