/xmlbench/trunk

#include <stdio.h>
#include <stdarg.h>
#include <sys/time.h>

#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/framework/MemBufInputSource.hpp>
#include <xercesc/framework/MemBufFormatTarget.hpp>
#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/dom/DOM.hpp>

#ifndef XSEC_NO_XALAN
# include <xalanc/XalanTransformer/XalanTransformer.hpp>
#endif

#include <xsec/framework/XSECProvider.hpp>
#include <xsec/framework/XSECException.hpp>
#include <xsec/dsig/DSIGReference.hpp>
#include <xsec/enc/OpenSSL/OpenSSLCryptoKeyRSA.hpp>
#include <xsec/xenc/XENCCipher.hpp>
#include <xsec/xenc/XENCEncryptedData.hpp>
#include <xsec/xenc/XENCEncryptedKey.hpp>
#include <xsec/enc/OpenSSL/OpenSSLCryptoSymmetricKey.hpp>
#include <xsec/enc/OpenSSL/OpenSSLCryptoX509.hpp>

#include <openssl/rand.h>

#include <xsec/enc/XSECCryptoException.hpp>

#include "xerces-dom.h"

#include "tools.h"

#define keyfile "../ssl/test.key"
#define crtfile "../ssl/test.crt"


XSEC_USING_XERCES(DOMImplementation);
#if XERCES_VERSION_MAJOR <= 2
XSEC_USING_XERCES(DOMWriter);
#endif
XSEC_USING_XERCES(XMLPlatformUtils);
XSEC_USING_XERCES(XMLException);
XSEC_USING_XERCES(DOMImplementationRegistry);
XSEC_USING_XERCES(MemBufFormatTarget);
XSEC_USING_XERCES(DOMImplementationLS);
XSEC_USING_XERCES(XercesDOMParser);
XSEC_USING_XERCES(MemBufInputSource);

#ifndef XSEC_NO_XALAN
XALAN_USING_XALAN(XalanTransformer)
#endif

XERCES_CPP_NAMESPACE_USE

XSECProvider *prov;

OpenSSLCryptoKeyRSA *key;
OpenSSLCryptoKeyRSA *vkey;

OpenSSLCryptoSymmetricKey *skey;
unsigned char keyBuf[24];

XercesDOMParser *parser = NULL;
DOMImplementation *dom; 
DOMDocument *signdoc;
DOMElement *sigNode;

#if XERCES_VERSION_MAJOR > 2
DOMLSSerializer   *writer;
DOMLSOutput       *output;
#else
DOMWriter *writer;
#endif
XMLFormatTarget *xft;

void initXML(struct TestData *td) {
    XMLPlatformUtils::Initialize();
#ifndef XSEC_NO_XALAN
    XalanTransformer::initialize();
#endif
    XSECPlatformUtils::Initialise();

    prov = new XSECProvider;

    dom = DOMImplementationRegistry::getDOMImplementation(MAKE_UNICODE_STRING("Core"));


    xft = new MemBufFormatTarget();
    
#if XERCES_VERSION_MAJOR > 2
    writer = ((DOMImplementationLS*)dom)->createLSSerializer();
    output = ((DOMImplementationLS*)dom)->createLSOutput();
    output->setByteStream(xft);
#else
    writer = ((DOMImplementationLS*)dom)->createDOMWriter();
#endif
}


void releaseXML(struct TestData *td) {
    if (parser) {
	delete parser;
	parser = NULL;
    }
    
    delete key;
    delete vkey;

    delete skey;
    
//    delete sigNode; SEGFAULT
//    delete signdoc;

    delete xft;
#if XERCES_VERSION_MAJOR > 2
    delete output;
#endif
    delete writer;

    XSECPlatformUtils::Terminate();
#ifndef XSEC_NO_XALAN
    XalanTransformer::terminate();
#endif
    XMLPlatformUtils::Terminate();
}


void initXML_Security(struct TestData *td) {
/*
    signdoc = dom->createDocument(0, MAKE_UNICODE_STRING("Signature"), NULL);  
    DSIGSignature *sig = prov->newSignature();
    sigNode = sig->createBlankSignature(signdoc, CANON_C14N_COM, SIGNATURE_RSA, HASH_SHA1);
    DSIGReference * ref = sig->createReference(MAKE_UNICODE_STRING(""));
    ref->appendEnvelopedSignatureTransform();
*/

	// Initialising Random Generator
    if (RAND_status() != 1) {
	fprintf(stderr,"OpenSSL random generation not properly initialised");
	exit(1);
    }
	// Generating Symmetric Key
    if (RAND_bytes(keyBuf, 24) == 0) {
	fprintf(stderr,"Error obtaining 24 bytes of random from OpenSSL");
	exit(1);
    }
 
    skey = new OpenSSLCryptoSymmetricKey(XSECCryptoSymmetricKey::KEY_3DES_192);
    skey->setKey(keyBuf, 24);



    EVP_PKEY *okey = LoadKey(keyfile, NULL, 1);
    if (!okey) {
	fprintf(stderr,"Error: can't load private key\n");
	exit(1);
    }

    key = new OpenSSLCryptoKeyRSA(okey);
    EVP_PKEY_free(okey);

    okey = LoadKey(crtfile, NULL, 0);
    if (!okey) {
	fprintf(stderr,"Error: can't load certificate\n");
	exit(1);
    }
    vkey = new OpenSSLCryptoKeyRSA(okey);
    EVP_PKEY_free(okey);
}


void parseXML(struct TestData *td, unsigned long iter) {
    const char id[5]="ID1\0";
    MemBufInputSource *buffer;

    if (parser) {
        delete parser;
    }

    parser = new XercesDOMParser;
    buffer=new MemBufInputSource((XMLByte*)td->xml,td->xmllen,(const char*)&id);
    buffer->setCopyBufToStream(false);
    parser->parse(*buffer);
    delete buffer;
}


void signXML(struct TestData *td, unsigned long iter) { 
    DOMDocument *doc = parser->getDocument();
    DOMElement *rootElem = doc->getDocumentElement();

/*
    DOMNode *node = doc->importNode(sigNode,1);
    rootElem->appendChild(node);
    DSIGSignature *sig = prov->newSignatureFromDOM(doc);
    try {
	sig->load();
	sig->setSigningKey(key->clone());    
	sig->sign();
    }
*/

    DSIGSignature *sig = prov->newSignature();
    DOMNode *node = sig->createBlankSignature(doc, CANON_C14N_NOC, SIGNATURE_RSA, HASH_SHA1);
    DSIGReference * ref = sig->createReference(MAKE_UNICODE_STRING(""));
    ref->appendEnvelopedSignatureTransform();
    rootElem->appendChild(node);
    try {
	sig->setSigningKey(key->clone());    
	sig->sign();
    }
    catch (XSECException &e)
    {
	fprintf(stderr,"Error signing: %s\n", (char*)e.getMsg());
	exit(1);
    }
    catch (XSECCryptoException &e) {
    	fprintf(stderr,"Error signing: %s\n", e.getMsg());
	exit(1);
    }

/*    
    if (iter==td->iterations) 
    {
        XMLByte *mem;
#if XERCES_VERSION_MAJOR > 2
	writer->write(doc, output);
#else
	writer->writeNode(xft,*doc);
#endif
	mem=(XMLByte*)((MemBufFormatTarget*)xft)->getRawBuffer();
	puts((char*)mem);
	((MemBufFormatTarget*)xft)->reset();
    }
*/
    prov->releaseSignature(sig);
}

void verifyXML(struct TestData *td, unsigned long iter) { 
    DOMDocument *doc = parser->getDocument();

    DSIGSignature *vsig = prov->newSignatureFromDOM(doc);

    try {
	vsig->load();
	vsig->setSigningKey(vkey->clone());

	if (!vsig->verify()) {
	    fprintf(stderr,"Error: Verification Failed\n");
	    exit(1);
	}
    }
    catch (XSECException &e)
    {
	fprintf(stderr,"Error validating: %s\n", (char*)e.getMsg());
	exit(1);
    }
    catch (XSECCryptoException &e) {
    	fprintf(stderr,"Error validating: %s\n", e.getMsg());
	exit(1);
    }

    prov->releaseSignature(vsig);
}

void encryptXML(struct TestData *td, unsigned long iter) { 
	DOMDocument *doc = parser->getDocument();
	DOMElement *rootElem = doc->getDocumentElement();

	try {
		/* Create the cipher object that we need */
		XENCCipher *cipher;
		cipher = prov->newCipher(doc);
		cipher->setKey(skey->clone());
		cipher->encryptElement(rootElem, ENCRYPT_3DES_CBC);
		cipher->setKEK(vkey->clone());

		XENCEncryptedKey * encryptedKey = cipher->encryptKey(keyBuf, 24, ENCRYPT_RSA_15);
		XENCEncryptedData * encryptedData = cipher->getEncryptedData();
		encryptedData->appendEncryptedKey(encryptedKey);
		prov->releaseCipher(cipher);
	}
	catch (XSECException &e)
	{
	    fprintf(stderr, "Error encrypting: %s\n",e.getMsg());
	    exit(1);
	}
/*
	if (iter==0) 
	{
    	    XMLByte *mem;
#if XERCES_VERSION_MAJOR > 2
	    writer->write(doc, output);
#else
	    writer->writeNode(xft,*doc);
#endif
	    mem=(XMLByte*)((MemBufFormatTarget*)xft)->getRawBuffer();
	    puts((char*)mem);
	    ((MemBufFormatTarget*)xft)->reset();
	}
*/

    return;
}

void decryptXML(struct TestData *td, unsigned long iter) { 
    DOMDocument *doc = parser->getDocument();
    
    try {    
	XENCCipher *cipher;
	cipher = prov->newCipher(doc);
	cipher->setKEK(key->clone());
	DOMNode *encryptedNode = findXENCNode(doc, "EncryptedData");

	    // As for CVS 08.02.2004 randomly drops core... Offten.. Don't vary on size...
	cipher->decryptElement((DOMElement *) encryptedNode);

	    // Here is problem. We are realsing Root Element, New Element is not set as root.
	    // Fix for this silly thing
	if (!doc->getDocumentElement()) {
	    DOMNode *tmpnode=doc->getFirstChild();
	    while ((tmpnode)&&(tmpnode->getNodeType()!=DOMNode::ELEMENT_NODE)) tmpnode=tmpnode->getNextSibling();
	    if (tmpnode) {
		doc->removeChild(tmpnode);
		doc->appendChild(tmpnode);
	    }
	    else {
		fprintf(stderr,"Error: Broken DOM tree after encryption/decryption!\n");
	        exit(1);
	    }
	}
	prov->releaseCipher(cipher);
    }
    catch (XSECException &e)
    {
	fprintf(stderr, "Error decrypting: %s\n",e.getMsg());
	exit(1);
    }
/*
    if (iter==0) 
    {
        XMLByte *mem;
#if XERCES_VERSION_MAJOR > 2
	writer->write(doc, output);
#else
	writer->writeNode(xft,*doc);
#endif
	mem=(XMLByte*)((MemBufFormatTarget*)xft)->getRawBuffer();
	puts((char*)mem);
	((MemBufFormatTarget*)xft)->reset();
    }
*/
    return;
}


int main(int argc, char *argv[]) {
    return Test(argc,argv);
}