Yet another TaskDialog wrapper, this time for WPF!

There are a lot of .NET projects out there for adding TaskDialog support for your Windows applications. They can do this (relatively) easily enough by simply wrapping a lot of calls and types to the Win32 API directly, most importantly the TaskDialogIndirect function and its related TASKDIALOGCONFIG data structure.

A custom STS in .NET, Part 6: Further reading

There's a lot more that's involved in this custom STS stuff, such as certificates, validation, custom RSTs, and even making a dedicated Claims WCF Service to further hide some of the STS stuff from your apps, but they typically are specific to individual needs. Just know that there is a ton of room for further customization. But again, this is all supposed to be a temporary quick-and-dirty STS solution to tide you over, right? You go much further and you might as well write your own dedicated STS application.

There are a lot of really great resources to help you with the concepts I've gone over and more. Here are just a few of the ones I used:

• Microsoft's Patterns & Practices Guide to Claims Based Identity
• A Crash Course in WIF
• Claims Based WPF Guide (and excellent sample source)
• Programming Windows Identity Foundation
• WIF Workshop video series
• Using a SQL Server DB with ADFS2
• WIF SDK (be sure to check the folder it installs to for sample code)
• Identity Developer Training Kit (also has lots of great samples)
• Security Token Visualizer Control (includes Fabrikam Airlines sample)

A custom STS in .NET, Part 5: Getting active

In order for your STS to work with web services (in particular, WCF ones), you're going to need to expose it another way besides the standard web page handling passive requests. Whether you implemented the passive case or not, be sure you've implemented some custom Claims filling logic since the same code will run regardless of whether it was initiated passively or actively.

A custom STS in .NET, Part 4: Responding with practical claims data

Previously we set up a simple almost-out-of-the-box passive STS web application. Right now it should respond to passive requests and everything should be fine, except that the claims data it responds with probably isn't very useful. The default code simply replies with a hard-coded name and role (probably “Manager”). Why don't we improve that a bit?

A custom STS in .NET, Part 3: Passively cool(ed?)

You should now have a basic web app project with some default files pasted in — wait, you did follow along in the first post, right? Do you know where you are?

A custom STS in .NET, Part 2: An STS for the rest of us

In our quest to develop a temporary yet functional STS to tide us over we must expect that it will take a bit of work. Even with the time invested, it can still be very much worth the trouble if it means having a working STS for your developers to code against. Seeing their application working, with claims-based security no less, can and should bring tears to their eyes and make real to them the value of having it. Furthermore, there's nothing like a live example to show your manager (or higher-ups).

A custom STS in .NET, Part 1: Claims-based security done piecemeal

After studying the theories and analyzing the current conditions at your workplace, you've come up with a radically new (well, new for them at least) application security solution! Involving databases, WS-Federation, and countless other features and complexities, it will be the one-stop flexible solution for all security needs across your intranet and even internet applications. It'll even account for cross-company security! Encryption! Hacker defense! Oh my!

And then comes the crushing realization: there is no way you can develop and introduce all of the pieces to this monolithic security solution at once without it crushing the current system under its massive (though decoupled and elegant!) size.

Thankfully, the decoupled nature of claims-based and WS-Federation style security lends itself wonderfully for implementing the pieces individually and gradually introducing them over time.