DSIGSignature.hpp

Go to the documentation of this file.

/*
 * Copyright 2002-2005 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 * XSEC
 *
 * DSIGSignature := Class for checking and setting up signature nodes in a DSIG signature
 *
 * Author(s): Berin Lautenbach
 *
 * $Id: DSIGSignature.hpp,v 1.26 2005/06/04 11:30:25 blautenb Exp $
 *
 */

#ifndef DSIGSIGNATURE_INCLUDE
#define DSIGSIGNATURE_INCLUDE

// XSEC Includes
#include <xsec/utils/XSECSafeBufferFormatter.hpp>
#include <xsec/dsig/DSIGTransform.hpp>
#include <xsec/dsig/DSIGKeyInfoList.hpp>
#include <xsec/dsig/DSIGConstants.hpp>
#include <xsec/dsig/DSIGSignedInfo.hpp>

// Xerces Includes

#include <xercesc/dom/DOM.hpp>

class XSECEnv;
class XSECBinTXFMInputStream;
class XSECURIResolver;
class XSECKeyInfoResolver;
class DSIGKeyInfoValue;
class DSIGKeyInfoX509;
class DSIGKeyInfoName;
class DSIGKeyInfoPGPData;
class DSIGKeyInfoSPKIData;
class DSIGKeyInfoMgmtData;
class DSIGObject;

/*\@{*/

class DSIG_EXPORT DSIGSignature {

protected:

    
    DSIGSignature(XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *doc, 
                  XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *sigNode);

    ~DSIGSignature();
    
public:


    void load(void);

    void setSigningKey(XSECCryptoKey *k);



    bool verify(void);

    bool verifySignatureOnly(void);

    void sign(void);

    
    void setDSIGNSPrefix(const XMLCh * prefix);

    void setECNSPrefix(const XMLCh * prefix);

    void setXPFNSPrefix(const XMLCh * prefix);

    void setPrettyPrint(bool flag);

    bool getPrettyPrint(void);

    XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *createBlankSignature(
        XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *doc,
        canonicalizationMethod cm = CANON_C14N_NOC,
        signatureMethod sm = SIGNATURE_DSA,
        hashMethod hm = HASH_SHA1
    );

    DSIGReference * createReference(
        const XMLCh * URI,
        hashMethod hm = HASH_SHA1, 
        char * type = NULL
    );



    unsigned int calculateSignedInfoAndReferenceHash(unsigned char * hashBuf, 
                                                    unsigned int hashBufLen);

    unsigned int calculateSignedInfoHash(unsigned char * hashBuf, 
                                        unsigned int hashBufLen);

    DSIGReferenceList * getReferenceList(void);

    XSECBinTXFMInputStream * makeBinInputStream(void) const;


    const XMLCh * getErrMsgs(void);

    const XMLCh * getDSIGNSPrefix();

    const XMLCh * getECNSPrefix();

    const XMLCh * getXPFNSPrefix();

    XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument * getParentDocument() 
        {return mp_doc;}

    canonicalizationMethod getCanonicalizationMethod(void) 
    {return (mp_signedInfo != NULL ? 
             mp_signedInfo->getCanonicalizationMethod() : CANON_NONE);}


    hashMethod getHashMethod(void)
    {return (mp_signedInfo != NULL ? 
             mp_signedInfo->getHashMethod() : HASH_NONE);}

    signatureMethod getSignatureMethod(void)
    {return (mp_signedInfo != NULL ? 
             mp_signedInfo->getSignatureMethod() : SIGNATURE_NONE);}

    const XMLCh * getSignatureValue(void) const;
         
    XSECSafeBufferFormatter * getSBFormatter(void) {return mp_formatter;}



    void setURIResolver(XSECURIResolver * resolver);

    XSECURIResolver * getURIResolver(void);

    void setKeyInfoResolver(XSECKeyInfoResolver * resolver);

    XSECKeyInfoResolver * getKeyInfoResolver(void);



    DSIGKeyInfoList * getKeyInfoList() {return &m_keyInfoList;}

    void clearKeyInfo(void);

    DSIGKeyInfoValue * appendDSAKeyValue(const XMLCh * P, 
                           const XMLCh * Q, 
                           const XMLCh * G, 
                           const XMLCh * Y);

    DSIGKeyInfoValue * appendRSAKeyValue(const XMLCh * modulus, 
                           const XMLCh * exponent);

    DSIGKeyInfoX509 * appendX509Data(void);

    DSIGKeyInfoName * appendKeyName(const XMLCh * name, bool isDName = false);

    DSIGKeyInfoPGPData * appendPGPData(const XMLCh * id, const XMLCh * packet);

    DSIGKeyInfoSPKIData * appendSPKIData(const XMLCh * sexp);

    DSIGKeyInfoMgmtData * appendMgmtData(const XMLCh * data);



    DSIGObject * appendObject(void);

    int getObjectLength(void);

    DSIGObject * getObjectItem(int i);



    void setIdByAttributeName(bool flag);

    bool getIdByAttributeName(void);

    void registerIdAttributeName(const XMLCh * name);

    bool deregisterIdAttributeName(const XMLCh * name);

    void registerIdAttributeNameNS(const XMLCh * ns, const XMLCh * name);

    bool deregisterIdAttributeNameNS(const XMLCh * ns, const XMLCh * name);


    friend class XSECProvider;

private:

    // For holding DSIGObject nodes
#if defined(XSEC_NO_NAMESPACES)
    typedef vector<DSIGObject *>            ObjectVectorType;
#else
    typedef std::vector<DSIGObject *>       ObjectVectorType;
#endif


    // Internal functions
    void createKeyInfoElement(void);
    bool verifySignatureOnlyInternal(void);

    XSECSafeBufferFormatter     * mp_formatter;
    bool                        m_loaded;               // Have we already loaded?
    XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument                  
                                * mp_doc;
    XERCES_CPP_NAMESPACE_QUALIFIER DOMNode                      
                                * mp_sigNode;
    DSIGSignedInfo              * mp_signedInfo;
    XERCES_CPP_NAMESPACE_QUALIFIER DOMNode                      
                                * mp_signatureValueNode;
    safeBuffer                  m_signatureValueSB;
    DSIGKeyInfoList             m_keyInfoList;
    XERCES_CPP_NAMESPACE_QUALIFIER DOMNode                      
                                * mp_KeyInfoNode;
    safeBuffer                  m_errStr;

    // Environment
    XSECEnv                     * mp_env;
    
    // The signing/verifying key
    XSECCryptoKey               * mp_signingKey;

    // Resolvers
    XSECKeyInfoResolver         * mp_KeyInfoResolver;

    // Objects

    ObjectVectorType            m_objects;

    // Not implemented constructors

    DSIGSignature();

    /*\@}*/
};

#endif /* DSIGSIGNATURE_INCLUDE */

---