shibsp/attribute/KeyInfoAttributeDecoder.cpp

   1 /**
   2  * Licensed to the University Corporation for Advanced Internet
   3  * Development, Inc. (UCAID) under one or more contributor license
   4  * agreements. See the NOTICE file distributed with this work for
   5  * additional information regarding copyright ownership.
   6  *
   7  * UCAID licenses this file to you under the Apache License,
   8  * Version 2.0 (the "License"); you may not use this file except
   9  * in compliance with the License. You may obtain a copy of the
  10  * License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  17  * either express or implied. See the License for the specific
  18  * language governing permissions and limitations under the License.
  19  */
  20
  21 /**
  22  * KeyInfoAttributeDecoder.cpp
  23  *
  24  * Decodes KeyInfo information into a SimpleAttribute.
  25  */
  26
  27 #include "internal.h"
  28 #include "attribute/AttributeDecoder.h"
  29 #include "attribute/SimpleAttribute.h"
  30
  31 #include <saml/saml1/core/Assertions.h>
  32 #include <saml/saml2/core/Assertions.h>
  33 #include <xmltooling/XMLToolingConfig.h>
  34 #include <xmltooling/security/Credential.h>
  35 #include <xmltooling/security/KeyInfoResolver.h>
  36 #include <xmltooling/security/SecurityHelper.h>
  37 #include <xmltooling/signature/KeyInfo.h>
  38
  39 using namespace shibsp;
  40 using namespace opensaml;
  41 using namespace xmlsignature;
  42 using namespace xmltooling;
  43 using namespace boost;
  44 using namespace std;
  45
  46 namespace shibsp {
  47     class SHIBSP_DLLLOCAL KeyInfoAttributeDecoder : virtual public AttributeDecoder
  48     {
  49     public:
  50         KeyInfoAttributeDecoder(const DOMElement* e);
  51         ~KeyInfoAttributeDecoder() {}
  52
  53         Attribute* decode(
  54             const vector<string>& ids, const XMLObject* xmlObject, const char* assertingParty=nullptr, const char* relyingParty=nullptr
  55             ) const;
  56
  57     private:
  58         void extract(const KeyInfo* k, vector<string>& dest) const {
  59             scoped_ptr<Credential> cred(getKeyInfoResolver()->resolve(k, Credential::RESOLVE_KEYS));
  60             if (cred) {
  61                 dest.push_back(string());
  62                 dest.back() = SecurityHelper::getDEREncoding(*cred, m_hash ? m_keyInfoHashAlg.c_str() : nullptr);
  63                 if (dest.back().empty())
  64                     dest.pop_back();
  65             }
  66         }
  67
  68         const KeyInfoResolver* getKeyInfoResolver() const {
  69             return m_keyInfoResolver ? m_keyInfoResolver.get() : XMLToolingConfig::getConfig().getKeyInfoResolver();
  70         }
  71
  72         bool m_hash;
  73         string m_keyInfoHashAlg;
  74         scoped_ptr<KeyInfoResolver> m_keyInfoResolver;
  75     };
  76
  77     AttributeDecoder* SHIBSP_DLLLOCAL KeyInfoAttributeDecoderFactory(const DOMElement* const & e)
  78     {
  79         return new KeyInfoAttributeDecoder(e);
  80     }
  81
  82     static const XMLCh _KeyInfoResolver[] = UNICODE_LITERAL_15(K,e,y,I,n,f,o,R,e,s,o,l,v,e,r);
  83     static const XMLCh _hash[] =            UNICODE_LITERAL_4(h,a,s,h);
  84     static const XMLCh keyInfoHashAlg[] =   UNICODE_LITERAL_14(k,e,y,I,n,f,o,H,a,s,h,A,l,g);
  85     static const XMLCh _type[] =            UNICODE_LITERAL_4(t,y,p,e);
  86 };
  87
  88 KeyInfoAttributeDecoder::KeyInfoAttributeDecoder(const DOMElement* e)
  89     : AttributeDecoder(e),
  90         m_hash(XMLHelper::getAttrBool(e, false, _hash)),
  91         m_keyInfoHashAlg(XMLHelper::getAttrString(e, "SHA1", keyInfoHashAlg)) {
  92     e = XMLHelper::getFirstChildElement(e, _KeyInfoResolver);
  93     if (e) {
  94         string t(XMLHelper::getAttrString(e, nullptr, _type));
  95         if (t.empty())
  96             throw UnknownExtensionException("<KeyInfoResolver> element found with no type attribute");
  97         m_keyInfoResolver.reset(XMLToolingConfig::getConfig().KeyInfoResolverManager.newPlugin(t.c_str(), e));
  98     }
  99 }
 100
 101 Attribute* KeyInfoAttributeDecoder::decode(
 102     const vector<string>& ids, const XMLObject* xmlObject, const char* assertingParty, const char* relyingParty
 103     ) const
 104 {
 105     Category& log = Category::getInstance(SHIBSP_LOGCAT".AttributeDecoder.KeyInfo");
 106
 107     if (!xmlObject || !XMLString::equals(saml1::Attribute::LOCAL_NAME, xmlObject->getElementQName().getLocalPart())) {
 108         log.warn("XMLObject type not recognized by KeyInfoAttributeDecoder, no values returned");
 109         return nullptr;
 110     }
 111
 112     auto_ptr<SimpleAttribute> attr(new SimpleAttribute(ids));
 113     vector<string>& dest = attr->getValues();
 114     vector<XMLObject*>::const_iterator v,stop;
 115
 116     const saml2::Attribute* saml2attr = dynamic_cast<const saml2::Attribute*>(xmlObject);
 117     if (saml2attr) {
 118         const vector<XMLObject*>& values = saml2attr->getAttributeValues();
 119         v = values.begin();
 120         stop = values.end();
 121         if (log.isDebugEnabled()) {
 122             auto_ptr_char n(saml2attr->getName());
 123             log.debug(
 124                 "decoding KeyInfo information (%s) from SAML 2 Attribute (%s) with %lu value(s)",
 125                 ids.front().c_str(), n.get() ? n.get() : "unnamed", values.size()
 126                 );
 127         }
 128     }
 129     else {
 130         const saml1::Attribute* saml1attr = dynamic_cast<const saml1::Attribute*>(xmlObject);
 131         if (saml1attr) {
 132             const vector<XMLObject*>& values = saml1attr->getAttributeValues();
 133             v = values.begin();
 134             stop = values.end();
 135             if (log.isDebugEnabled()) {
 136                 auto_ptr_char n(saml1attr->getAttributeName());
 137                 log.debug(
 138                     "decoding KeyInfo information (%s) from SAML 1 Attribute (%s) with %lu value(s)",
 139                     ids.front().c_str(), n.get() ? n.get() : "unnamed", values.size()
 140                     );
 141             }
 142         }
 143         else {
 144             log.warn("XMLObject type not recognized by KeyInfoAttributeDecoder, no values returned");
 145             return nullptr;
 146         }
 147     }
 148
 149     for (; v!=stop; ++v) {
 150         const KeyInfo* k = dynamic_cast<const KeyInfo*>(*v);
 151         if (k)
 152             extract(k, dest);
 153         else if ((*v)->hasChildren()) {
 154             const list<XMLObject*>& children = (*v)->getOrderedChildren();
 155             for (list<XMLObject*>::const_iterator vv = children.begin(); vv != children.end(); ++vv) {
 156                 if (k=dynamic_cast<const KeyInfo*>(*vv))
 157                     extract(k, dest);
 158                 else
 159                     log.warn("skipping AttributeValue without a recognizable KeyInfo");
 160             }
 161         }
 162     }
 163
 164     return dest.empty() ? nullptr : _decode(attr.release());
 165 }