Encrypting data with a dynamicaly created template.

Home Download News Documentation FAQ Tutorial API reference Examples XML Digital Signature Online Verifier XML Encryption XML Canonicalization Reporting Bugs Mailing list Related
XML Security Library Reference Manual
<<< Previous Page | Home | Up | Next Page >>>
# Encrypting data with a dynamicaly created template. ## encrypt2.c
    /**
     * XML Security Library example: Encrypting XML file with a dynamicaly created template.
     *
     * Encrypts XML file using a dynamicaly created template file and a DES key
     * from a binary file
     *
     * Usage:
     *	./encrypt2 <xml-doc> <des-key-file>
     *
     * Example:
     *	./encrypt2 encrypt2-doc.xml deskey.bin > encrypt2-res.xml
     *
     * The result could be decrypted with decrypt1 example:
     *	./decrypt1 encrypt2-res.xml deskey.bin
     *
     * This is free software; see Copyright file in the source
     * distribution for preciese wording.
     *
     * Copyrigth (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>
     */
    #include <stdlib.h>
    #include <string.h>
    #include <assert.h>

    #include <libxml/tree.h>
    #include <libxml/xmlmemory.h>
    #include <libxml/parser.h>

    #ifndef XMLSEC_NO_XSLT
    #include <libxslt/xslt.h>
    #endif /* XMLSEC_NO_XSLT */

    #include <xmlsec/xmlsec.h>
    #include <xmlsec/xmltree.h>
    #include <xmlsec/xmlenc.h>
    #include <xmlsec/templates.h>
    #include <xmlsec/crypto.h>

    int encrypt_file(const char* xml_file, const char* key_file);

    int
    main(int argc, char **argv) {
        assert(argv);

        if(argc != 3) {
    	fprintf(stderr, "Error: wrong number of arguments.\n");
    	fprintf(stderr, "Usage: %s <xml-file> <key-file>\n", argv[0]);
    	return(1);
        }

        /* Init libxml and libxslt libraries */
        xmlInitParser();
        LIBXML_TEST_VERSION
        xmlLoadExtDtdDefaultValue = XML_DETECT_IDS | XML_COMPLETE_ATTRS;
        xmlSubstituteEntitiesDefault(1);
    #ifndef XMLSEC_NO_XSLT
        xmlIndentTreeOutput = 1;
    #endif /* XMLSEC_NO_XSLT */

        /* Init xmlsec library */
        if(xmlSecInit() < 0) {
    	fprintf(stderr, "Error: xmlsec initialization failed.\n");
    	return(-1);
        }

        /* Init crypto library */
        if(xmlSecCryptoAppInit(NULL) < 0) {
    	fprintf(stderr, "Error: crypto initialization failed.\n");
    	return(-1);
        }

        /* Init xmlsec-crypto library */
        if(xmlSecCryptoInit() < 0) {
    	fprintf(stderr, "Error: xmlsec-crypto initialization failed.\n");
    	return(-1);
        }

        if(encrypt_file(argv[1], argv[2]) < 0) {
    	return(-1);
        }

        /* Shutdown xmlsec-crypto library */
        xmlSecCryptoShutdown();

        /* Shutdown crypto library */
        xmlSecCryptoAppShutdown();

        /* Shutdown xmlsec library */
        xmlSecShutdown();

        /* Shutdown libxslt/libxml */
    #ifndef XMLSEC_NO_XSLT
        xsltCleanupGlobals();
    #endif /* XMLSEC_NO_XSLT */
        xmlCleanupParser();

        return(0);
    }

    /**
     * encrypt_file:
     * @xml_file:		the encryption template file name.
     * @key_file:		the Triple DES key file.
     *
     * Encrypts #xml_file using a dynamicaly created template and DES key from
     * #key_file.
     *
     * Returns 0 on success or a negative value if an error occurs.
     */
    int
    encrypt_file(const char* xml_file, const char* key_file) {
        xmlDocPtr doc = NULL;
        xmlNodePtr encDataNode = NULL;
        xmlNodePtr keyInfoNode = NULL;
        xmlSecEncCtxPtr encCtx = NULL;
        int res = -1;

        assert(xml_file);
        assert(key_file);

        /* load template */
        doc = xmlParseFile(xml_file);
        if ((doc == NULL) || (xmlDocGetRootElement(doc) == NULL)){
    	fprintf(stderr, "Error: unable to parse file \"%s\"\n", xml_file);
    	goto done;
        }

        /* create encryption template to encrypt XML file and replace
         * its content with encryption result */
        encDataNode = xmlSecTmplEncDataCreate(doc, xmlSecTransformDes3CbcId,
    				NULL, xmlSecTypeEncElement, NULL, NULL);
        if(encDataNode == NULL) {
    	fprintf(stderr, "Error: failed to create encryption template\n");
    	goto done;
        }

        /* we want to put encrypted data in the <enc:CipherValue/> node */
        if(xmlSecTmplEncDataEnsureCipherValue(encDataNode) == NULL) {
    	fprintf(stderr, "Error: failed to add CipherValue node\n");
    	goto done;
        }

        /* add <dsig:KeyInfo/> and <dsig:KeyName/> nodes to put key name in the signed document */
        keyInfoNode = xmlSecTmplEncDataEnsureKeyInfo(encDataNode, NULL);
        if(keyInfoNode == NULL) {
    	fprintf(stderr, "Error: failed to add key info\n");
    	goto done;
        }

        if(xmlSecTmplKeyInfoAddKeyName(keyInfoNode, NULL) == NULL) {
    	fprintf(stderr, "Error: failed to add key name\n");
    	goto done;
        }

        /* create encryption context, we don't need keys manager in this example */
        encCtx = xmlSecEncCtxCreate(NULL);
        if(encCtx == NULL) {
            fprintf(stderr,"Error: failed to create encryption context\n");
    	goto done;
        }

        /* load DES key, assuming that there is not password */
        encCtx->encKey = xmlSecKeyReadBinaryFile(xmlSecKeyDataDesId, key_file);
        if(encCtx->encKey == NULL) {
            fprintf(stderr,"Error: failed to load des key from binary file \"%s\"\n", key_file);
    	goto done;
        }

        /* set key name to the file name, this is just an example! */
        if(xmlSecKeySetName(encCtx->encKey, key_file) < 0) {
        	fprintf(stderr,"Error: failed to set key name for key from \"%s\"\n", key_file);
    	goto done;
        }

        /* encrypt the data */
        if(xmlSecEncCtxXmlEncrypt(encCtx, encDataNode, xmlDocGetRootElement(doc)) < 0) {
            fprintf(stderr,"Error: encryption failed\n");
    	goto done;
        }

        /* we template is inserted in the doc */
        encDataNode = NULL;

        /* print encrypted data with document to stdout */
        xmlDocDump(stdout, doc);

        /* success */
        res = 0;

    done:

        /* cleanup */
        if(encCtx != NULL) {
    	xmlSecEncCtxDestroy(encCtx);
        }

        if(encDataNode != NULL) {
    	xmlFreeNode(encDataNode);
        }

        if(doc != NULL) {
    	xmlFreeDoc(doc);
        }
        return(res);
    }
## encrypt2-doc.xml
    <?xml version="1.0" encoding="UTF-8"?>
    <!--
    XML Security Library example: Original XML doc file before encryption (encrypt2 example).
    -->
    <Envelope xmlns="urn:envelope">
      <Data>
    	Hello, World!
      </Data>
    </Envelope>
## encrypt2-res.xml
    <?xml version="1.0" encoding="UTF-8"?>
    <!--
    XML Security Library example: Encrypted XML file (encrypt2 example).
    -->
    <EncryptedData xmlns="http://www.w3.org/2001/04/xmlenc#" Type="http://www.w3.org/2001/04/xmlenc#Element">
    <EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#tripledes-cbc"/>
    <KeyInfo xmlns="http://www.w3.org/2000/09/xmldsig#">
    <KeyName>deskey.bin</KeyName>
    </KeyInfo>
    <CipherData>
    <CipherValue>WXlDyktaADlUe+PywKwS3KdKlahCteEKxi/hRlHcXNQlGwNGrYKy8aQ6dLtX1bKg
    IgL/XoAQN3B27zD91b1ZLGh6QQ9CjnVD98+hYJ9TPp4piPnII4vGUA==</CipherValue>
    </CipherData>
    </EncryptedData>
<<< Previous Page | Home | Up | Next Page >>>
Encrypting data with a template file. | Encrypting data with a session key.
Aleksey Sanin