Claims Articles / Blogs / Perficient https://blogs.perficient.com/tag/claims/ Expert Digital Insights Thu, 30 Sep 2021 20:04:23 +0000 en-US hourly 1 https://blogs.perficient.com/files/favicon-194x194-1-150x150.png Claims Articles / Blogs / Perficient https://blogs.perficient.com/tag/claims/ 32 32 30508587 Federated Authentication in Sitecore 9 – Part 3: Implementation of SAML2p https://blogs.perficient.com/2018/06/06/federated-authentication-in-sitecore-9-part-3-implementation-of-saml2p/ https://blogs.perficient.com/2018/06/06/federated-authentication-in-sitecore-9-part-3-implementation-of-saml2p/#comments Wed, 06 Jun 2018 14:00:36 +0000 https://blogs.perficient.com/sitecore/?p=37544

Let’s jump into implementing the code for federated authentication in Sitecore!
If you’ve missed Part 1 and/or Part 2 of this 3 part series examining the federated authentication capabilities of Sitecore, feel free to read those first to get set up and then come back for the code.
Part 1: Overview
Part 2: Configuration
For this example, we’ll be using the SAML2p library by Sustainsys – formerly known as Kentor. You’ll see some references to Kentor in the code – the version available as of this blog post is still in the middle of the process of renaming so you’ll see the “Kentor” name scattered around the code. Just know that this is the Sustainsys SAML2p library.
Fortunately the library provides OWIN middleware for authentication so it will be fairly straightforward to implement. There are a couple of sections that will need to be configured:

Registering the SAML2 Identity Provider

The SAML2 identity provider will need to be registered in Sitecore to be used with the appropriate sites. More details around this config file can be found in Part 2. For now, this is the config file for the SAML2 identity provider:

There is nothing particularly special about this configuration – just be aware that there is a mapping in this config that maps everyone who logs in with the saml2 identity provider to be administrators. You should most definitely take that out.

Injecting into the OWIN Pipeline through the Sitecore <owin.identityProviders> Pipeline

Now comes the fun code part! We’ll need to create a class that overrides Sitecore.Owin.Authentication.Pipelines.IdentityProviders.IdentityProvidersProcessor. This will be a Sitecore pipeline processor that Sitecore will execute at the appropriate time in the OWIN pipeline for authentication. The ProcessCore method is where you’ll be doing all the work for the authentication. The method provides a parameter of type Sitecore.Owin.Authentication.Pipelines.IdentityProviders.IdentityProvidersArgs that provides a reference to Owin.IAppBuilder to which you can hook up middleware. You’ll see in the code below that some options are set for the Sustainsys SAML2 OWIN middleware and the code args.App.UseSaml2Authentication(options) is called. This registers the SAML2 middleware with the OWIN pipeline.

Executing Claims Transforms on the ClaimsIdentity

In your identity provider configuration, you have the option of setting claims transformations for that specific identity provider. However, there are some shared claims transformations that apply to all providers – one in particular that is in by default is the one for the idp claim. You’ll notice in line 41 of Saml2IdentityProviderProcessor.cs that there is a hook into a notification provided by the SAML2 middleware that will execute the following code:
var identityProvider = GetIdentityProvider();
((ClaimsIdentity)result.Principal.Identity).ApplyClaimsTransformations(new TransformationContext(FederatedAuthenticationConfiguration, identityProvider));

Basically, this ensures that after authentication is complete, all of the claims transformations are executed on the returned ClaimsIdentity so that the expected claims are being created on the identity. This should be executed whenever authentication is complete – other authentication middlewares may provide other events such as OnAuthenticate that you can hook into and execute similar code.
Believe it or not, that’s it! This is a more complex example than usual due to its need for an external library, however, there are built in NuGet packages for other authentication providers that are quite straightforward to set up. If you’d like to see this example and others, including implementations for Facebook, Google, and Azure AD with OpenID Connect, feel free to peruse this GitHub repository. Enjoy!

]]>
https://blogs.perficient.com/2018/06/06/federated-authentication-in-sitecore-9-part-3-implementation-of-saml2p/feed/ 1 269283
Transforming With Optimism in the Insurance Industry https://blogs.perficient.com/2018/05/01/transforming-with-optimism-in-the-insurance-industry/ https://blogs.perficient.com/2018/05/01/transforming-with-optimism-in-the-insurance-industry/#respond Tue, 01 May 2018 11:45:25 +0000 https://blogs.perficient.com/?p=181948

Mario Greco, CEO of Zurich Insurance Group, one of the world’s largest insurance companies, sat down with CNBC following the release of the company’s Q4 2017 earnings. He shared his views on how the industry is doing as a whole, as well as how Zurich is maintaining its leadership position in such a competitive environment.

“The industry is in a fantastic state of transformation. It’s something that we’ve been waiting for a long time. It is exciting. It’s happening very, very fast, and very quickly,” Greco said. When speaking specifically about his company’s growth plan, Greco said the company is “riding this wave of transformation” and that it has every intention of continuing to invest in assets that help the company expand its ability to reach and serve new customers. “We’re transforming the way we’re dealing with the customers, and we’ll continue doing that.”

Greco’s positive tone and outlook on the industry isn’t unique by a long shot. Even after a year full of natural disasters (2017 happens to be the costliest year on record for the global insurance industry) and the potential financial burden (i.e., more claims) that climate change can place on insurers moving forward, the overall feeling about the future is optimistic. That optimism comes from the stability these companies have managed to develop. It stems from a focus on the fundamentals of the business, which includes pricing and assuming risk, interest earnings, and revenue, as well as claims and loss handling. After all, the Holy Grail for insurance companies is to market effectively and minimize administration costs.

To learn what else is driving growth, productivity, and efficiency, download our new guide: 2018 State of the Insurance Industry.

]]>
https://blogs.perficient.com/2018/05/01/transforming-with-optimism-in-the-insurance-industry/feed/ 0 181948
Why You Shouldn’t Miss This “IBM Watson For Insurance” Webinar https://blogs.perficient.com/2017/06/14/why-you-shouldnt-miss-this-ibm-watson-for-insurance-webinar/ https://blogs.perficient.com/2017/06/14/why-you-shouldnt-miss-this-ibm-watson-for-insurance-webinar/#respond Wed, 14 Jun 2017 13:15:32 +0000 https://blogs.perficient.com/2017/06/14/why-you-shouldnt-miss-this-ibm-watson-for-insurance-webinar/

Although it’s been on YouTube for less than a month, IBM’s Watson at Work: Insurance video has been viewed over 1.2 million times. That’s because insurance companies are keen to streamline their claims processes.

If the number of views isn’t enough to convince you that insurers are all about Watson, consider this: Amica Mutual Insurance, Great-West Life & Annuity Insurance Company, Swiss Re Group, Česká pojišťovna, British Columbia Automobile Association (BCAA), Southern Farm Bureau Life Insurance Company, AXA, and Nationwide Mutual Insurance Company – all wildly successful insurance companies – shared how they have been leveraging Watson at last year’s World of Watson event.

https://www.youtube.com/watch?v=0qqLLrEkNEc

Watson is proving to be everything we thought it would be, which is why we’ve invested heavily in working with Watson and partnering with IBM. In fact, we were hand-picked by IBM executives and industry analysts for the 2017 IBM Beacon Award for an Outstanding Watson Solution.

Oh, and, my awesome colleague and the director of our Watson practice, Christine Livingston, sat down with IBM CEO Ginni Rometty to chat about Watson. Cool, eh?!

So, without further ado, I’d like to personally invite you to a webinar, in which that very same Christine Livingston, along with Graham Wallis, the director of our business process management (BPM) practice, will share how Watson and BPM are transforming the insurance industry. You don’t want to miss it!

]]>
https://blogs.perficient.com/2017/06/14/why-you-shouldnt-miss-this-ibm-watson-for-insurance-webinar/feed/ 0 173911
How Watson and BPM Are Disrupting Insurance https://blogs.perficient.com/2017/06/07/how-watson-and-bpm-are-disrupting-insurance/ https://blogs.perficient.com/2017/06/07/how-watson-and-bpm-are-disrupting-insurance/#respond Wed, 07 Jun 2017 11:32:39 +0000 https://blogs.perficient.com/ibm/?p=8631

If there’s one area that can spell the success or failure of an insurance carrier, it’s claims. Claims consume nearly 80% of insurance premiums in the form of payments or processing costs. Consequently, claims managers are challenged to reduce these costs, improve service levels, and gain greater control over the processing environment. As regulatory oversight and compliance become more stringent, claim volumes continue to increase. Claims managers must often cope with the inconsistent application of processing guidelines, which can boost transaction and claims costs. And, for those saddled with manual, paper-based processes, every aspect of handling a claim is slower – and more costly. According to one study, leveraging technology that transforms claims processing has the potential to reduce claims losses and expenses by up to 12%, and improve customer satisfaction.

Business process management has led transformation in the insurance industry for decades. With the emergence of cognitive technologies like IBM Watson, how can you further optimize complex, data-driven processes to gain a competitive advantage?

Join us for a webinar on June 20th to learn how to leverage cognitive solutions like IBM Watson to augment and enhance existing claims processes and transform your business. Perficient experts, Christine Livingston (Watson Practice Director), and Graham Wallis (BPM Practice Director), will cover common cognitive use cases, including:

  • Integrating claims processes with streamlined, automated interactive voice response systems
  • Supporting product classification leveraging images and unstructured text to aid compliance and onboarding processes

Register now with the form below!

 

]]>
https://blogs.perficient.com/2017/06/07/how-watson-and-bpm-are-disrupting-insurance/feed/ 0 214533
Servicing Customers In Financial Services With CX Technology https://blogs.perficient.com/2016/07/27/servicing-customers-in-financial-services-with-cx-technology/ https://blogs.perficient.com/2016/07/27/servicing-customers-in-financial-services-with-cx-technology/#respond Wed, 27 Jul 2016 14:34:19 +0000 https://blogs.perficient.com/2016/07/27/servicing-customers-in-financial-services-with-cx-technology/

It’s no secret that customer satisfaction scores go up when customers consistently get what they want. When they have unanswered questions about your products and services, they’re not likely to become your biggest cheerleaders. And, chances are that if your prospects find themselves with questions that can’t be answered, they’re not going to convert.

We see this all the time in banking. Visitors who use live chat for support are typically twice as likely to complete an application for a product, such as a loan, than those who don’t. Why is that? Immediacy is key. If you’re not there when they need you, they’ll go somewhere else where there’s help.

There are plenty of ways financial services companies can boost customer engagement, generate new business, and keep existing customers happy.

Can your customers search a knowledge base for answers? Can they book an appointment online and manage their account on a mobile device? How about use text messaging to find out balance information? Do you offer live text or video chat? With modern software, you have the ability to give the customer what they really want and expect in today’s world.

Join us for an upcoming webinar to learn how you can meet the high customer expectations created by companies like as Amazon.com through the use of Oracle Service Cloud and Oracle Policy Automation (OPA). To get a real taste of what can be done with this technology, we’ll even provide a live demonstration of using these solutions for loan applications.

]]>
https://blogs.perficient.com/2016/07/27/servicing-customers-in-financial-services-with-cx-technology/feed/ 0 174077
Token-Based Authentication: Part 1- JWT with DP Firmware 7.2.0.0 https://blogs.perficient.com/2015/12/21/token-based-authentication-part-1-jwt-with-dp-firmware-7-2-0-0/ https://blogs.perficient.com/2015/12/21/token-based-authentication-part-1-jwt-with-dp-firmware-7-2-0-0/#respond Tue, 22 Dec 2015 00:41:58 +0000 https://blogs.perficient.com/ibm/?p=5437

This tutorial series explains how to issue and validate different types of tokens such as JWT(JSON Web Token) , SAML HoK(Holder-of key) using IBM DataPower gateway. In this article, you learn about the issuance and validation of JWT with firmware v 7.2.0.0.

In Part-2, you will learn to issue and validate the JWT with firmware v 7.2.0.1 in much simpler way. In Part-3, I’ll explain about issuance and validation of SAML HoK token used for SOAP based services.

token based auth.

What is JSON Web Token

JSON Web Token (JWT) is a compact claims representation format intended for space constrained environments such as HTTP Authorization headers and URI query parameters. JWTs encode claims to be transmitted as a JavaScript Object Notation (JSON) object that is used as the payload of a JSON Web Signature (JWS) structure or as the plain-text of a JSON Web Encryption (JWE) structure. JWTs are always represented using the JWS Compact Serialization or the JWE Compact Serialization.

Here is an example of signed JWT. It’s comprised of 3 parts(highlighted in different colors) separated by a period (.)

Ist part is base-64 encoded JWS header value which contains information about signing algorithm. You can use any of the following algorithm to sign the Claim-set.

Asymmetric -> RS256, RS384, RS512

Symmetric -> HS256, HS384, HS512

2nd part is base-64 encoded JSON claim-set.

3rd part is base-64 encoded signature value generated after signing the encoded JWS header and payload (claim-set) with algorithm specified in JWS header.

eyJhbGciOiJSUzI1NiJ9.eyJpc3MiOiJpYm1fZGF0YXBvd2VyIiwic3ViIjoiYWRtaW4iLCJleHAiOjE0NTAxMTUyODAuMTkyLCJuYmYiOjE0NTAxMTE2NzkuMTkyLCJpYXQiOjE0NTAxMTE2ODAuMTkyLCJqdGkiOiI3ZjY2NGYxNi05OGQyLTRlYzEtODlhOS04NjM3ODBkYjFhNjgiLCJhdWQiOiJBQUFNb2JpbGUifQ.G7XRUjxrvRSdFE_RRumrPtTnLvlX36eRqDC0UFZKiO3Jau9iDbPuGPeGc0g0kUrubGQAqXz1TYTAuwcNnF58FWQjm9ovZrFH-fvGEpiYKjSctAsldj_ecQRw4jX5YKOYd1zbdr67-zUJN0n8J1iNJiJeVyGBCvz7jiiwCcZSXGRUkAqy-zwq_jULfZoi7QIS1s4f_K5WeQu4PVEhe30tovffegHdxAPZm0ptQT88l3UuuC5zNW7QxQH-6MywLvI3jYttrJ_jhIXUiNFyWDSkNKbcfUwjV2ez5IlPMfQgVFVoMMecaxJ5qlzRr8-okrpgaSQt5xx6gIL-gEZtV7Cd5g

Standard/Registered Claim names

None of the claims defined below are intended to be mandatory to use or implement in all cases, but rather, provide a starting point for a set of useful, interoperable claims. Applications using JWTs should define which specific claims they use and when they are required or optional. All the names are short because a core goal of JWTs is for the representation to be compact.

  • iss (Issuer)
  • sub (Subject)
  • aud (Audience)
  • exp (Expiration Time)
  • nbf (Not before)
  • iat (Issued At)
  • jti (JWT ID)

Take a look at following link to get more details around these claim names. We can even define the custom claims based on the requirement.

Claims Description

Using Firmware 7.2.0.0

As most of you will be aware of that Data Power firmware v 7.2 provide enhanced message-level security for mobile, API, and web workloads by using JSON Web Encryption for message confidentiality, JSON Signature for message integrity and JSON Web Token to assert security assertions for Single Sign On (SSO).

Though Firmware 7.2 does provide actions to Sign, Verify, and Encrypt and Decrypt the JSON payload but there are no such actions available to generate and validate JSON Web Tokens. You have to write the Gateway Script to perform these functionalities.

Here are the sample Gateway scripts that I developed to generate and validate JWT.

Post successful Authentication/Authorization, configure the following gateway script in GatewayScript action in Request processing rule to issue the token.

createJWT.js

 

// Import Required packages

var jose=require(‘jose’);

var jwt=require(‘jwt’);

var sm=require(‘service-metadata’);

sm.mpgw.skipBackside=true;

session.INPUT.readAsJSON(function(error,json)

{

if(error)

{

session.output.write(‘Error reading JSON’ + error);

}

else

{

var claims={

“iss”:”ibm_datapower”,

“aud”:”Audience_name”, // Replace ‘Audience Name’ with actual value.

“iat”: new Date().getTime(),

“exp”:(new Date().getTime()) + 10000, //Token will get expire in 10 sec.

};

//Sign the token with RS256 algorithm. Replace ‘Crypto Key Object Name’ with actual object name created on box.

var jwsHeader=jose.createJWSHeader(‘Crypto Key Object Name’,’RS256′);

var encoder=new jwt.Encoder(claims);

encoder.addOperation(‘sign’,jwsHeader)

.encode(function(error,token) {

if (error) {

session.output.write(‘Error creating JWT’ + error);

}

else {

session.output.write(token);

}

}

);

}

}

)

For validation, pass the JWT in HTTP header as shown below.

Authorization : Bearer “JWT string”

validateJWT.js

//Import Required Packages

var jwt=require(‘jwt’);

var hm=require(‘header-metadata’);

var sm=require(‘service-metadata’);

sm.mpgw.skipBackside=true;

 

//Retrieve Authorization HTTP Header value.

var bearertoken=hm.current.get(‘Authorization’);

// Retrieve the JWT token.

var buff=bearertoken.substring(7);

 

var jwttoken=buff.toString();

var decoder=new jwt.Decoder(jwttoken);

 

decoder.addOperation(‘verify’,’Crypto Cert Object Name’)

.addOperation(‘validate’,{‘aud’:’Audience_Name’})

.decode(function(error,claims) {

if(error)

{

session.output.write(‘Error validating JWT’ + error);

}

else

{

session.output.write(claims);

}

})

]]>
https://blogs.perficient.com/2015/12/21/token-based-authentication-part-1-jwt-with-dp-firmware-7-2-0-0/feed/ 0 214285
The Yeoman’s Guide to SP2013 Internet/Extranet Licensing: Part 2 https://blogs.perficient.com/2012/12/03/9990/ https://blogs.perficient.com/2012/12/03/9990/#respond Mon, 03 Dec 2012 20:04:36 +0000 http://blogs.perficient.com/microsoft/?p=9990

(This article is the second in a two-part series.  For Part 1, please click here.)
If I were a decision maker or purchasing manager in an enterprise IT department, this is how I’d like to view SharePoint CALs (CAL is shorthand for Client Access License in the Redmond Universe): a “solution first” approach that tells me what I’m getting and why.  How does it all work together?  Don’t tell me about Search, Web Content, and Mobility as separate swimlanes.  Tell me how they can be combined in a single solution that serves my business needs.
It’s with THAT perspective in mind that I want to look at Internet Sites and Extranets in SharePoint 2013.
Internet Sites
The best SP 2013 websites I’ve seen to date heavily leverage content by search– dynamic assembly of content– and mobile features.  If you look at these traditionally, they’re from two functional areas: “Search” and “Web Content”.  The reality is, they’re both equally important elements of a good SP 2013 internet site.

  • There is no longer a specific SKU for SharePoint Server For Internet Sites (the old “FIS” Server).  Following on this, there is no longer a FAST for Internet sites either.
  • Enterprise is further required if you want to use SharePoint for public-facing Internet sites.
  • The content by search webpart– which we leverage for dynamic content assembly– is available only in Enterprise.

The bottom line is that Internet sites in SharePoint 2013 are significantly less expensive to license than those built on SharePoint 2010 FIS, but boast significant leaps in functionality– device channels  and image renditions, metadata-driven navigation, dynamically-generated content, and content targeting– that were not available in the previous, significantly more expensive product.
Extranet Platforms
In general, an Extranet’s feature set tends to resemble the more collaborative aspects of an Intranet.  Unlike intranets, though, a thorn in the side of SharePoint Extranet projects for many years has been the issue of authentication.  Now that claims is the default for authentication to SharePoint, the road has been paved for Microsoft to address this issue… and address it they have.
Microsoft has made things a lot more comfortable for Extranet users– people not in your Active Directory or on your payroll that may include vendors, partners, contractors, or even customers.
Some key points for this solution:

  • The external users outlined above DO NOT NEED LICENSES (but internal users still require CALs for authentication– no free rides here!)  This is a nice line in the sand.  With Claims as the primary authentication method, you don’t need to worry about Active Directory anymore.
  • Extranets do face the Internet– so you do need Enterprise to make them work.
  • Office 365 users get 10,000 external user CALs.  That’s a whopping big extranet, and another great reason to think about the Microsoft cloud.

In summary, you now need SharePoint Enterprise to do either a public Internet site or an Extranet platform on SharePoint, but that’s not a bad thing.  It’s no longer prohibitively expensive, and beyond that, it’s packed with features to make it a better web content platform.  Got questions?  Shoot me an email at rich.wood@perficient.com.

]]>
https://blogs.perficient.com/2012/12/03/9990/feed/ 0 224193
What’s New in SharePoint 2013? Let’s ask the experts… https://blogs.perficient.com/2012/07/30/whats-new-in-sharepoint-2013-lets-ask-the-experts/ https://blogs.perficient.com/2012/07/30/whats-new-in-sharepoint-2013-lets-ask-the-experts/#respond Mon, 30 Jul 2012 15:29:29 +0000 http://blogs.perficient.com/microsoft/?p=6684

SharePoint 2013 (or “Wave 15” as we unabashed Microsoft fanboys have been calling it) has been in public beta for a little over two weeks now, and we’re starting to see some more discussion of new features and functions around the web.  Our own Microsoft blog is no exception.
A number of our customers have been involved in the TAP for SharePoint 2013 all along, and they’ve graciously allowed us to work with them in exploring the new technology and developing exciting new solutions since well before the public beta became available.
You might already have noticed that several of our consultants are sharing the deep knowledge they’ve built up in delving into these and other topics since early this year, but just in case you haven’t, I thought I’d call your attention to some of the “best of the blog” that we’ve published so far.

What have we got for you?  Try this on for size….
Amol Ajgaonkar has gone deep into a number of topics around Web Content Management that would be of interest to anyone looking at SharePoint as a platform for an intranet or internet sites.

Amol’s posts are not only well-detailed and easy to follow from a learning perspective, but they are chock-full of screen clippings and clear illustrations of what following his instructions actually looks like.
Andrew Schwenker tackles another topic of significant interest to anyone using SharePoint as the basis for their internet platform—claims.  You can’t keep all those users in Active Directory, after all!  In both an introductory post (“What Can Claims do for You?”) and a more detailed justification (“Your New Best Friend”), Andrew explains why claims-based authentication just might be the security solution for you.
We’ve also seen Will Tseng get into the game with a quick take on creating a managed property in SharePoint 2013 Search.  I’m very interested in seeing more from Will on Search, and getting a better feel for how Microsoft has further integrated the FAST product into SharePoint as a whole.
I’m sure there will be more where these came from, and soon.  Until then—stay tuned!

]]>
https://blogs.perficient.com/2012/07/30/whats-new-in-sharepoint-2013-lets-ask-the-experts/feed/ 0 224032
Planning for Externalizing Authentication in SharePoint 2010: Part 1 – Introduction https://blogs.perficient.com/2011/12/29/planning-for-externalizing-authentication-in-sharepoint-2010-part-1-introduction/ https://blogs.perficient.com/2011/12/29/planning-for-externalizing-authentication-in-sharepoint-2010-part-1-introduction/#respond Fri, 30 Dec 2011 00:37:42 +0000 http://blogs.pointbridge.com/Blogs/nielsen_travis/Pages/Post.aspx?_ID=47
Since the beginning of 2011, I’ve had the good fortune of being involved with several projects involving the claims authentication capabilities introduced in SharePoint 2010. The scope of these efforts have ranged from small proof-of-concept demonstrations to large Internet and Intranet production deployments. Some involved custom built Security Token Services (STS) and others relied on vendor-provided products like ADFS 2.0 and Ping Federate. As a sort of unofficial evangelist for this sort of thing, I’m impressed with how architects and developers, both from our consultants here at PointBridge and with our customers, have embraced the concept. In pretty much every case, we had a slightly different problem to solve and the technology has enabled us to deal with it in a straightforward way. Folks out there are “getting it” and I’m looking forward to helping advance this technology even further as we begin the new year.
So I thought this would be a good opportunity to share what are in my mind the key planning considerations when opting to use this approach for authentication. Note that for the purposes of this writing, when I say “externalizing authentication” I’m really talking about what Microsoft refers to as using “SAML claims”. In other words, using some sort of external STS (like ADFS 2.0 or Ping Federate) that issues tokens to be consumed by SharePoint for authentication.

What Do I Need to Plan For?

This can quickly become a pretty large and technical subject to discuss, so I’ll break this blog series into the main planning areas that I see need to be addressed:

  1. Authentication and Authorization: Identity Providers, STS, SAML tokens, claims, custom claims provider, web applications, zones
  2. Session Management: Token cache, sliding sessions, cookies
  3. Functionality: Custom controls and pages, Office integration, search
  4. Operations: Support processes and documentation

Note that in this series I won’t be covering much regarding the specifics for configuring external authentication for SharePoint 2010. That’s already well covered in previous posts I’ve written and also the following Microsoft whitepaper: Implementing Claims-Based Authentication with SharePoint Server 2010. Additionally, the recently released 2nd edition of “A Guide to Claims-Based Identity and Access Control” is pretty much required reading for anyone looking to get involved with this technology. My focus is going to be on what we’ve seen out there in the “real world”.

Before starting, have clear design objectives

Externalizing authentication will force your team to solve some things that are taken for granted when using traditional Windows-integrated authentication. Additional investments in time for development, testing, documentation, and operational procedures will be required to to ensure short and long term success. Therefore, I believe a strong justification for this approach is required. Externalizing authentication could be a good choice if the organization:

  1. Requires Single Sign On (SSO) or Web Sign On (OpenID, Facebook, Twitter, Google, etc…) with vendors or customers. Because SAML is “standards based” and provides a very high degree of interoperability, this is a common justification.
  2. Is undergoing a lot of transition with its directory services (acquisitions and migrations) and doesn’t want to be limited or held back by these changes. Externalizing authentication to a single “identity tier” creates a façade that enables SharePoint projects to move forward without being held hostage to other organizational initiatives.
  3. Does not have a centralized identity infrastructure and never will. It operates more as a federation of entities and interested parties and still wants to take advantage of SharePoint as a collaboration platform.
  4. Wishes to expose SharePoint 2010 to mobile devices.
  5. Requires one of more of it’s SharePoint sites to work like a banking banking site with automated sign-out during idle times and doesn’t have expertise to accomplish this at the gateway (firewalls / reverse proxies).
  6. Is looking to consolidate its web tier assets under a single identity infrastructure and enable more interoperability between applications. Claims authentication is fully supported in ASP.NET and Windows Communication Foundation, including REST web services. For obvious security reasons, this makes sense to standardize under a single authentication and authorization scheme, especially one that is as flexible as the various SAML-related protocols out there (WS-Trust and WS-Federation).
  7. Is making a commitment to “the cloud”. Because claims authentication fundamentally works with the web, it can be used to tie together on- and off-premise applications in a seamless manner. And this goes for SaaS solutions like Microsoft Office 365, which utilizes ADFS 2.0 to achieve SSO with your local instance of Active Directory.

These are just a few common examples….and in most cases more than one scenario would apply to a given project. I mention all this because I believe it’s important to always “keep an eye on the prize” when fighting through all the details and nuances that externalizing authentication requires.

So….does it work?

I get this question a lot. The short answer is: “Yes, but with some effort”. We here at PointBridge have several customers in production today using SAML claims – with some implementations going pretty deep into the search and collaboration features. But as I mentioned above, a successful result may require implementing a series of customizations to SharePoint; some of them minor and others more substantial. For example, the reality is that any production-quality deployment is going to need to implement a custom People Picker to resolve what the user enters to something real (a group or user account in AD, LDAP, or SQL). That’s not available out of the box and will require code. Fortunately, there are great examples out there on the ‘net to get you started.
SAML claims requires each user to have an attribute that uniquely identifies the account. Your team will have to take a hard look at the Identity Provider (Active Directory in many cases) to ensure this attribute exists and is 100% populated (and standardized). If the attribute involves a given name or surname, you will need to call out processes to handle name changes. An unhandled name change will result in a new user account in SharePoint and a whole lotta confusion for all parties involved.
Depending on your level of sensitivity to the end-user experience, you may find you’ll need to customize several SharePoint administrative pages such as the default “Access Denied” and “Request Access” pages, which by default expose the unfriendly claims identity of the end-user (example: 0e.t|externalprovider|joe.user@corpdomain.com). You may also find that you’ll need to update extra controls such as the “Sign Out” and “Sign on as a different user” components in the Welcome Menu control.
If your environment is going to support document management functionality, your team will need a solid understanding of the relationship between session cookies and the various versions of Microsoft Office.
Search (both FAST for SharePoint and standard search) will require that your web applications have a specific zone configuration so that content can be indexed. This configuratio
n may drive other “fixes” to ensure automatically generated links such as workflow task alerts point the the URL you want your end users to see.
Out of the box, tokens for authenticated sessions are stored in memory on each Web Front End. If you’re working in a multi- WFE farm topology and don’t have sticky sessions available…or your system has any sort of vulnerability to unplanned app pool recycles (which is probably everybody 🙂 ) , you should consider implementing a persistent token cache as opposed to relying on what Microsoft gives you.
And there are a couple of things you’ll have to give up. The Document Preview functionality in FAST for SharePoint is one of them.
Almost all of these things can be addressed….and I’ll cover that in future posts in this series. My point here is you should look at the advantages SAML claims brings to the table versus any risks and costs associated before jumping in. Obviously, this sort of evaluation is necessary for almost any newer technology and externalizing authentication is no different.

]]>
https://blogs.perficient.com/2011/12/29/planning-for-externalizing-authentication-in-sharepoint-2010-part-1-introduction/feed/ 0 223948
Unable to access SharePoint claims-based site – Event ID 8306 https://blogs.perficient.com/2011/10/12/unable-to-access-sharepoint-claims-based-site-event-id-8306/ https://blogs.perficient.com/2011/10/12/unable-to-access-sharepoint-claims-based-site-event-id-8306/#respond Wed, 12 Oct 2011 21:31:00 +0000 http://blogs.pointbridge.com/Blogs/crossland_apryl/Pages/Post.aspx?_ID=5
System Specs
SharePoint 2010 farm hosting multiple web apps using claims authentication. Each web app has multiple zones.
 
Symptoms
After a code deployment we were unable to access the Intranet zone (NTLM Authentication) for all claims-based we apps in the environment.
 
The following is the error that was encountered when trying to access the sites in IE.
The following is the error that was being captured in the Application event log.
Log Name: Application
Source: Microsoft-SharePoint Products-SharePoint Foundation
Date: 10/11/2011 8:37:04 PM
Event ID: 8306
Task Category: Claims Authentication
Level: Error
Description:
An exception occurred when trying to issue security token: The server was unable to process the request due to an internal error. For more information about the error, either turn on IncludeExceptionDetailInFaults (either from ServiceBehaviorAttribute or from the <serviceDebug> configuration behavior) on the server in order to send the exception information back to the client, or turn on tracing as per the Microsoft .NET Framework 3.0 SDK documentation and inspect the server trace logs.
Resolution
The following three services were in a stopped state. Once these services were started the sites started responding normally.
 
]]>
https://blogs.perficient.com/2011/10/12/unable-to-access-sharepoint-claims-based-site-event-id-8306/feed/ 0 223973
403 Forbidden Error with iPhone When Accessing SharePoint 2010 in Claims Mode https://blogs.perficient.com/2011/08/24/403-forbidden-error-with-iphone-when-accessing-sharepoint-2010-in-claims-mode/ https://blogs.perficient.com/2011/08/24/403-forbidden-error-with-iphone-when-accessing-sharepoint-2010-in-claims-mode/#respond Wed, 24 Aug 2011 16:36:22 +0000 http://blogs.pointbridge.com/Blogs/nielsen_travis/Pages/Post.aspx?_ID=46
If you’re looking to support iPhone on a SharePoint 2010 site that is configured to use an external identity provider like Ping Federate, ADFS 2.0, or a custom STS, you will likely run into this issue. However, you may notice everything works just fine with iPad. Fortunately, the issue can be reproduced on the desktop using Firefox or Safari by emulating the iPhone user agent and you’ll be able to see what’s going on in Fiddler.
image
As seen in the above screenshot, you’ll notice an additional redirect to /_layouts/mobile/mblmultilogin.aspx just before hitting the /_trust/default.aspx page. And indeed this is what causes the issue. To correct it, you’ll need to update iPhone Safari section within the Web Application’s compat.browser file and set the “isMobileDevice” property to false.
clip_image001
After making this change, your iPhone users should be able to enjoy the SharePoint experience from their phones. Yeah, that was a bit of sarcasm there….
]]>
https://blogs.perficient.com/2011/08/24/403-forbidden-error-with-iphone-when-accessing-sharepoint-2010-in-claims-mode/feed/ 0 223815
Claims SSO in an Anonymous Access SharePoint Environment https://blogs.perficient.com/2011/07/15/claims-sso-in-an-anonymous-access-sharepoint-environment/ https://blogs.perficient.com/2011/07/15/claims-sso-in-an-anonymous-access-sharepoint-environment/#respond Fri, 15 Jul 2011 21:38:48 +0000 http://blogs.pointbridge.com/Blogs/hulse_brian/Pages/Post.aspx?_ID=8
Note: The below method is good for both single sign on and persistent login scenarios in a SharePoint environment with anonymous access enabled.
I recently had to wrestle with implementing single sign on (SSO) between two SharePoint web applications that have anonymous access enabled. If you have read Programming Windows Identity Foundation (I recommend you do if you are planning on implementing claims authentication) you would know that to implement SSO between two secure SharePoint web applications with the same identity provider is not too difficult. If the user is authenticated to one application you can count on the default redirect of non-authenticated users from the second application to your identity provider. The provider will recognize that the user is already authenticated to it (after you program it to) and redirect you back to SharePoint to create the FedAuth cookie you need to access the second application.
Things start to get a little tricky when you throw anonymous access into the mix. The main difference being, you cannot rely on SharePoint to recognize that a new user needs to be authenticated to the STS. This was triggered by an anonymous user trying to access a secure site before, now that your application is anonymous SharePoint does not have this trigger to utilize. That means we are going to have to write some code to create our own trigger.
The solution consists of two parts, a user control on the SharePoint application, and an application page on your custom identity provider (sometimes called an STS or Secure Token Service). The control is going to make a JSON call to the page that lives on the provider. The page on the provider just returns whether or not the current user is authenticated. If the user is authenticated, the control will redirect the user to the provider to be authenticated to the new application.
Let’s take a look at the Render method of the control that will live on our SharePoint application. NOTE: this code is using the jQuery library to make the JSON call.

1: protected override void Render(System.Web.UI.HtmlTextWriter writer) 2: { 3: if (Page.Session.IsNewSession && !HttpContext.Current.User.Identity.IsAuthenticated) 4: { 5: SignInRequestMessage message = TrustedIdentityHelper.CreateTrustedSignInRequestMessage(); 6: 7: string STSUrl = TrustedIdentityHelper.STSUrl(); 8: 9: HttpContext.Current.Response.Write(String.Format(

"<script type="text/javascript">

10: $.getJSON(“{0}{1}”, null, 11: function (data) { 12: { if(data.IsAuthenticated.toLowerCase() == “true”) 13: {{window.location.replace(“{2}”); }} 14: }}) </script>”, 15: STSUrl, 16: “AuthCheck.aspx?Callback=?”, 17: message.RequestUrl)); 18: } 19: 20: base.Render(writer); 21: }

.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode, .ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode pre
{font-size:small;color:black;font-family:consolas, “Courier New”, courier, monospace;background-color:#ffffff;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode pre
{margin:0em;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .rem
{color:#008000;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .kwrd
{color:#0000ff;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .str
{color:#006080;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .op
{color:#0000c0;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .preproc
{color:#cc6633;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .asp
{background-color:#ffff00;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .html
{color:#800000;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .attr
{color:#ff0000;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .alt
{background-color:#f4f4f4;width:100%;margin:0em;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .lnum
{color:#606060;}
You can see that I have a class which assists with creating sign in request messages as well as gives me the URL to my custom provider; I will use both of these if the current user needs to be authenticated. This control outputs javascript on the page that makes a JSON call to AuthCheck.aspx which is located on the identity provider site. If the call returns true (i.e. the user is authenticated to the identity provider) then I redirect the user to the provider to be authenticated. The reason that I only fire this control when it is a new session is because if I took that check out this control would make a JSON call to the STS for every anonymous request. If you have a high traffic site, having a lot of people making frequent JSON calls to your identity provider could cause performance problems.
The AuthCheck.aspx page that receives the JSON call from this control and returns the result is very simple, it is a basic page with a few lines of code in the Page_Load method.
Here is the code for that:

1: protected void Page_Load(object sender, EventArgs e) 2: { 3: Response.ContentType = “text/javascript”; 4: string callback = Request[“Callback”]; 5: 6: Response.Write(String.Format(“{0} ({{“IsAuthenticated” : “{1}”}})”, callback, User.Identity.IsAuthenticated.ToString())); 7: }

.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode, .ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode pre
{font-size:small;color:black;font-family:consolas, “Courier New”, courier, monospace;background-color:#ffffff;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode pre
{margin:0em;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .rem
{color:#008000;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .kwrd
{color:#0000ff;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .str
{color:#006080;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .op
{color:#0000c0;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .preproc
{color:#cc6633;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .asp
{background-color:#ffff00;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .html
{color:#800000;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .attr
{color:#ff0000;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .alt
{background-color:#f4f4f4;width:100%;margin:0em;}
.ExternalClassDD2020F98DAE47F59C5986460CDE3F61 .csharpcode .lnum
{color:#606060;}
That is the gist!

]]>
https://blogs.perficient.com/2011/07/15/claims-sso-in-an-anonymous-access-sharepoint-environment/feed/ 0 223827