X-Git-Url: http://www.project-moonshot.org/gitweb/?a=blobdiff_plain;f=shibsp%2Fattribute%2FAttribute.cpp;h=89f69bffba2fa235502d1652bf903fe837a3da8d;hb=b82d57bd8c43c92141bdf871da8d8d79170c72a8;hp=36c32bc7d7d52e82948ec7933d5ae5e2bf23b7bb;hpb=2d31c38a125c630fc259f086d3d938c12745b42b;p=shibboleth%2Fsp.git diff --git a/shibsp/attribute/Attribute.cpp b/shibsp/attribute/Attribute.cpp index 36c32bc..89f69bf 100644 --- a/shibsp/attribute/Attribute.cpp +++ b/shibsp/attribute/Attribute.cpp @@ -1,5 +1,5 @@ /* - * Copyright 2001-2009 Internet2 + * Copyright 2001-2010 Internet2 * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -21,6 +21,7 @@ */ #include "internal.h" +#include "exceptions.h" #include "SPConfig.h" #ifndef SHIBSP_LITE # include "attribute/AttributeDecoder.h" @@ -32,34 +33,20 @@ #include "attribute/XMLAttribute.h" #include "util/SPConstants.h" -#include #include +#include +#include using namespace shibsp; using namespace xmltooling; using namespace std; namespace shibsp { - - SHIBSP_DLLLOCAL Attribute* SimpleAttributeFactory(DDF& in) { - return new SimpleAttribute(in); - } - - SHIBSP_DLLLOCAL Attribute* ScopedAttributeFactory(DDF& in) { - return new ScopedAttribute(in); - } - - SHIBSP_DLLLOCAL Attribute* NameIDAttributeFactory(DDF& in) { - return new NameIDAttribute(in); - } - - SHIBSP_DLLLOCAL Attribute* ExtensibleAttributeFactory(DDF& in) { - return new ExtensibleAttribute(in); - } - - SHIBSP_DLLLOCAL Attribute* XMLAttributeFactory(DDF& in) { - return new XMLAttribute(in); - } + SHIBSP_DLLLOCAL Attribute* SimpleAttributeFactory(DDF& in); + SHIBSP_DLLLOCAL Attribute* ScopedAttributeFactory(DDF& in); + SHIBSP_DLLLOCAL Attribute* NameIDAttributeFactory(DDF& in); + SHIBSP_DLLLOCAL Attribute* ExtensibleAttributeFactory(DDF& in); + SHIBSP_DLLLOCAL Attribute* XMLAttributeFactory(DDF& in); #ifndef SHIBSP_LITE SHIBSP_DLLLOCAL PluginManager::Factory StringAttributeDecoderFactory; @@ -69,6 +56,7 @@ namespace shibsp { SHIBSP_DLLLOCAL PluginManager::Factory KeyInfoAttributeDecoderFactory; SHIBSP_DLLLOCAL PluginManager::Factory DOMAttributeDecoderFactory; SHIBSP_DLLLOCAL PluginManager::Factory XMLAttributeDecoderFactory; + SHIBSP_DLLLOCAL PluginManager::Factory Base64AttributeDecoderFactory; static const XMLCh _StringAttributeDecoder[] = UNICODE_LITERAL_22(S,t,r,i,n,g,A,t,t,r,i,b,u,t,e,D,e,c,o,d,e,r); static const XMLCh _ScopedAttributeDecoder[] = UNICODE_LITERAL_22(S,c,o,p,e,d,A,t,t,r,i,b,u,t,e,D,e,c,o,d,e,r); @@ -77,8 +65,14 @@ namespace shibsp { static const XMLCh _KeyInfoAttributeDecoder[] =UNICODE_LITERAL_23(K,e,y,I,n,f,o,A,t,t,r,i,b,u,t,e,D,e,c,o,d,e,r); static const XMLCh _DOMAttributeDecoder[] = UNICODE_LITERAL_19(D,O,M,A,t,t,r,i,b,u,t,e,D,e,c,o,d,e,r); static const XMLCh _XMLAttributeDecoder[] = UNICODE_LITERAL_19(X,M,L,A,t,t,r,i,b,u,t,e,D,e,c,o,d,e,r); + static const XMLCh _Base64AttributeDecoder[] = { + chLatin_B, chLatin_a, chLatin_s, chLatin_e, chDigit_6, chDigit_4, + chLatin_A, chLatin_t, chLatin_t, chLatin_r, chLatin_i, chLatin_b, chLatin_u, chLatin_t, chLatin_e, + chLatin_D, chLatin_e, chLatin_c, chLatin_o, chLatin_d, chLatin_e, chLatin_r, chNull + }; static const XMLCh caseSensitive[] = UNICODE_LITERAL_13(c,a,s,e,S,e,n,s,i,t,i,v,e); + static const XMLCh hashAlg[] = UNICODE_LITERAL_7(h,a,s,h,A,l,g); static const XMLCh internal[] = UNICODE_LITERAL_8(i,n,t,e,r,n,a,l); #endif }; @@ -91,6 +85,7 @@ xmltooling::QName shibsp::NameIDFromScopedAttributeDecoderType(shibspconstants:: xmltooling::QName shibsp::KeyInfoAttributeDecoderType(shibspconstants::SHIB2ATTRIBUTEMAP_NS, _KeyInfoAttributeDecoder); xmltooling::QName shibsp::DOMAttributeDecoderType(shibspconstants::SHIB2ATTRIBUTEMAP_NS, _DOMAttributeDecoder); xmltooling::QName shibsp::XMLAttributeDecoderType(shibspconstants::SHIB2ATTRIBUTEMAP_NS, _XMLAttributeDecoder); +xmltooling::QName shibsp::Base64AttributeDecoderType(shibspconstants::SHIB2ATTRIBUTEMAP_NS, _Base64AttributeDecoder); void shibsp::registerAttributeDecoders() { @@ -102,19 +97,44 @@ void shibsp::registerAttributeDecoders() conf.AttributeDecoderManager.registerFactory(KeyInfoAttributeDecoderType, KeyInfoAttributeDecoderFactory); conf.AttributeDecoderManager.registerFactory(DOMAttributeDecoderType, DOMAttributeDecoderFactory); conf.AttributeDecoderManager.registerFactory(XMLAttributeDecoderType, XMLAttributeDecoderFactory); + conf.AttributeDecoderManager.registerFactory(Base64AttributeDecoderType, Base64AttributeDecoderFactory); } -AttributeDecoder::AttributeDecoder(const DOMElement *e) : m_caseSensitive(true), m_internal(false) +AttributeDecoder::AttributeDecoder(const DOMElement *e) + : m_caseSensitive(XMLHelper::getAttrBool(e, true, caseSensitive)), + m_internal(XMLHelper::getAttrBool(e, false, internal)), + m_hashAlg(XMLHelper::getAttrString(e, nullptr, hashAlg)) { - if (e) { - const XMLCh* flag = e->getAttributeNS(NULL, caseSensitive); - if (flag && (*flag == chLatin_f || *flag == chDigit_0)) - m_caseSensitive = false; +} + +AttributeDecoder::~AttributeDecoder() +{ +} + +Attribute* AttributeDecoder::_decode(Attribute* attr) const +{ + if (attr) { + attr->setCaseSensitive(m_caseSensitive); + attr->setInternal(m_internal); + + if (!m_hashAlg.empty()) { + // We turn the values into strings using the supplied hash algorithm and return a SimpleAttribute instead. + auto_ptr simple(new SimpleAttribute(attr->getAliases())); + simple->setCaseSensitive(false); + simple->setInternal(m_internal); + vector& newdest = simple->getValues(); + const vector& serialized = attr->getSerializedValues(); + for (vector::const_iterator ser = serialized.begin(); ser != serialized.end(); ++ser) { + newdest.push_back(SecurityHelper::doHash(m_hashAlg.c_str(), ser->data(), ser->length())); + if (newdest.back().empty()) + newdest.pop_back(); + } + delete attr; + return newdest.empty() ? nullptr : simple.release(); + } - flag = e->getAttributeNS(NULL, internal); - if (flag && (*flag == chLatin_t || *flag == chDigit_1)) - m_internal = true; } + return attr; } #endif @@ -130,6 +150,25 @@ void shibsp::registerAttributeFactories() map Attribute::m_factoryMap; +void Attribute::registerFactory(const char* type, AttributeFactory* factory) +{ + m_factoryMap[type] = factory; +} + +void Attribute::deregisterFactory(const char* type) +{ + m_factoryMap.erase(type); +} + +void Attribute::deregisterFactories() +{ + m_factoryMap.clear(); +} + +Attribute::Attribute(const vector& ids) : m_id(ids), m_caseSensitive(true), m_internal(false) +{ +} + Attribute::Attribute(DDF& in) : m_caseSensitive(in["case_insensitive"].isnull()), m_internal(!in["internal"].isnull()) { const char* id = in.first().name(); @@ -147,9 +186,74 @@ Attribute::Attribute(DDF& in) : m_caseSensitive(in["case_insensitive"].isnull()) } } +Attribute::~Attribute() +{ +} + +const char* Attribute::getId() const +{ + return m_id.front().c_str(); +} + +const vector& Attribute::getAliases() const +{ + return m_id; +} + +vector& Attribute::getAliases() +{ + return m_id; +} + +void Attribute::setCaseSensitive(bool caseSensitive) +{ + m_caseSensitive = caseSensitive; +} + +void Attribute::setInternal(bool internal) +{ + m_internal = internal; +} + +bool Attribute::isCaseSensitive() const +{ + return m_caseSensitive; +} + +bool Attribute::isInternal() const +{ + return m_internal; +} + +size_t Attribute::valueCount() const +{ + return m_serialized.size(); +} + +const vector& Attribute::getSerializedValues() const +{ + return m_serialized; +} + +const char* Attribute::getString(size_t index) const +{ + return m_serialized[index].c_str(); +} + +const char* Attribute::getScope(size_t index) const +{ + return nullptr; +} + +void Attribute::removeValue(size_t index) +{ + if (index < m_serialized.size()) + m_serialized.erase(m_serialized.begin() + index); +} + DDF Attribute::marshall() const { - DDF ddf(NULL); + DDF ddf(nullptr); ddf.structure().addmember(m_id.front().c_str()).list(); if (!m_caseSensitive) ddf.addmember("case_insensitive"); @@ -159,7 +263,7 @@ DDF Attribute::marshall() const DDF alias; DDF aliases = ddf.addmember("aliases").list(); for (std::vector::const_iterator a = m_id.begin() + 1; a != m_id.end(); ++a) { - alias = DDF(NULL).string(a->c_str()); + alias = DDF(nullptr).string(a->c_str()); aliases.add(alias); } } @@ -173,27 +277,3 @@ Attribute* Attribute::unmarshall(DDF& in) throw AttributeException("No registered factory for Attribute of type ($1).", params(1,in.name())); return (i->second)(in); } - -const vector& XMLAttribute::getSerializedValues() const -{ - xsecsize_t len; - XMLByte *pos, *pos2; - if (m_serialized.empty()) { - for (vector::const_iterator i=m_values.begin(); i!=m_values.end(); ++i) { - XMLByte* enc = Base64::encode(reinterpret_cast(i->data()), i->size(), &len); - if (enc) { - for (pos=enc, pos2=enc; *pos2; pos2++) - if (isgraph(*pos2)) - *pos++=*pos2; - *pos=0; - m_serialized.push_back(reinterpret_cast(enc)); -#ifdef SHIBSP_XERCESC_HAS_XMLBYTE_RELEASE - XMLString::release(&enc); -#else - XMLString::release((char**)&enc); -#endif - } - } - } - return Attribute::getSerializedValues(); -}