The Hogg Blog : Security

SecPAL Parser Updated for VS2008 and F#1.9.6.16

Jason Hogg — Sun, 27 Sep 2009 01:27:00 GMT

I finally got around to updating the SecPAL Parser to run on the latest version of Visual Studio and F#. Development experience should be much cleaner now because F# is far better integrated into VS. If you run into any problems please post a note or drop me an email. For more information please see our SecPAL CodeBox Community Site.

A Graphical DSL for Describing SOA Applications

Jason Hogg — Wed, 28 Jan 2009 09:05:00 GMT

Last October we ran a SOA workshop in Redmond, with the goal being to have members of the MCS field, global practices and other customer facing organizations discuss scenarios and patterns that they see on a regular basis. Having run several of these workshops in the psat, one challenge that is hard to overcome is ensuring people describe their scenarios and solutions in a standard way.

Given the lack of a standard vocabulary for many (most?) domains within our industry this is obviously made more difficult. In an attempt to overcome this shortfall myself, Piyush Gupta and Sudarsan Srinivasan spent about a month decomposing a number of customer solutions into their constituent patterns - thus building a catalog of patterns that participants at our workshop could use when describing solutions to their scenarios. Where such patterns were already documented, we normalized on terms from sources such as Hohpe's Integration Patterns, SOA Patterns, Workflow Patterns, Patterns and Practices and IBM's dev center.

Even armed with a standard vocabulary, the next problem becomes how do you succinctly present complex system designs without requiring large numbers of UML objects. Christopher Alexander aluded to the solution to this problem through the use of a visual notation to accompany each pattern. So I searched around and found that Matthew Oskowis had created a nice little Visio template including icons for each of Gregor Hohpe's patterns. This helped us for about 50% of the patterns and so I extended it to include the additional patterns that we had identified.

When using this visual notation it became too difficult expecting everyone to recognize each of these icons, so I also extended each icon to include the pattern name. It makes the diagrams a little clumsy - but they are still quite readable. As you can see in the diagram below it is also obvious that these icons convey a lot of information in a small amount of space - more so than an equivalent UML model would for example.

The diagram below illustrates one such example, where a service agent is performing requestor side caching allowing configuration information to be retrieved from a central configuration service and cached. The Configuration Notification Service also allows the client (should it subscribe) to be notified of changes to this configuration.

For my presentation for tomorrow's SOA BP conference I will be walking through a number of scenarios using this SOA DSL, so figured I would first post it on the blog for people that are interested in using it. If you use it or extend it let me know how you go, or share your updates.

Are banks encouraging phone phishing attacks?

Jason Hogg — Wed, 07 Jan 2009 02:29:00 GMT

I recently called the support number to verify a charge on my Wells Fargo account and it surprised me when the automated teller requested that I enter my card number and then my pin number. I was always lead to believe that we should never share our pin numbers as that obviously breaches the security of our ATM cards - so I hung up and waited until I could talk with a customer representative. I just spoke with such a representative and apparently the bank is ok for you to share your pin number with an automated teller.

This seems very strange to me as how am I to determine whether in fact I am talking with an automated teller owned by Wells Fargo or an automated teller owned by someone with malicious intent. This possibility is greatly increased by the large number of phone numbers that the banks have - preventing me from even really knowing whether I am talking with Wells Fargo or not. This is made all the worse given the large number of phone numbers that banks appear to have nowadays. The enquiry I just made has had me dial 4 different numbers during which time I was also transferred 3 times - meaning I really have no idea who I am talking to. I can also imagine would be perpetrators obtaining numbers that are 1 digit off of major banks and obtaining ATM card information that way.

Is it just me or does this seem like a huge risk? Or is there something that I am missing here in terms of why this isn't a security risk? Also, do banks other than Wells Fargo also require customers to enter their pin numbers?

Geneva Identity Management Framework

Jason Hogg — Mon, 27 Oct 2008 22:08:00 GMT

For anyone who has followed my blogs around developing an STS or writing authorization policies you will be very interested in Kim Cameron's announcement at PDC of the Geneva Identity Management platform. Genvea includes:

Geneva Framework - A .NET framework for writing interoperable, claims aware applicatoins
Geneva STS - An STS integrated with AD. Supports issuance (finally) and consumption of Cardspace Cards.
CardSpace Geneva - A federation client

In addition to these framework like components, there are also a couple of services (biult using Geneva) including:

Microsoft Federation Gateway - Provides the basis for the Microsoft Services Identity backbone - brokering access to Microsoft cloud applications and developre services
Microsoft Connector Services - Federates AD to the Microsoft Federation Gateway. Provides lightweight access to the federation gateway.
.NET Access Control Service - Next generation service (STS) that performs claims transformation. It receives authentication information and issues authz decisions. This includes a management portal and API's for managing and writing authz policies.

I haven't had a chance to play with any of these tools yet, but will be very interested to see how the Access Control Service's capabilities compare with SecPAL... :-)

patterns & practices Improving Web Services Security: Now Available!

Jason Hogg — Fri, 20 Jun 2008 17:51:00 GMT

Over the last 12 months we have had a lot of people who used the Web Service Security - Scenarios, Patterns and Implementation Guidance ask us where the implementation guidance for WCF was. Great news. JD Meier, Jason Taylor, Prashant Bansode and Rob Boucher and the rest of his P&P team have just released their guide which includes Security Fundamentals for Web Services, WCF Security Fundamentals and Scenario specific guidance. Great stuff - and a must read for anyone designing secure distributed systems based on WCF. Available from: http://www.codeplex.com/WCFSecurityGuide

SAML STS for WSE 3.0 (reposted)

Jason Hogg — Wed, 21 Nov 2007 09:36:00 GMT

Every week or so I get another email asking where the sample code for the SAML STS for WSE 3.0 has been moved to now that GotDotNet GotNuked. It wasn't moved anywhere. So I figured I would repost it here for those that needs i. For those new to this you should also take a look at Pablo Cibraro's blog (Pablo was one of the developers on this sample) as he extended this to support credential caching and more.

A few caveats that people should be aware of when looking at this sample code:

For obvious reasons, where at all possibly you should seek a WCF based solution first. There still appear to be a few people that cannot use WCF yet - which is why I am reposting this.
We did do interop testing between a RC version of WCF and this STS - but this was released before WCF went gold - so if interop is important to you then you should test that.
The code within this requires extensive knowledge of .NET security API's. Do not consider deploying this if you do not understand the entire solution.
As with all things security related you should ensure you put together an appropriate security threat model and as part of your solution design...
And of course batteries are not included!

Most common issues encountered:

Configuring the access rights to the certifcates is probably the number one issue people run into. If you need help managing certs / permissions download this awesome tool.

Sample declarative access control policy

Jason Hogg — Wed, 29 Aug 2007 02:29:00 GMT

In my previous post I mentioned that we have now released a parser for SecPAL that allows policies to be written in a human readable simplified English grammar. I thought it might be worth including an example - based on the scenario that was used in the GridToday post on Access Control in Grid Computing Environments which (funnily enough) is very similar to the two pages of F# available here and very similar to the C# sample AttributeScenario solution included inside the v1.1 release of SecPAL.

The sample shows the policies being specified in C# using a similar approach to that you might use to specify dynamic SQL. Such policies could just as easily be read from a file etc. In the future I will provide some more advanced samples - including more discussion about each of the samples - but for now just remember that another of SecPAL's strengths is its ability to create generic access control policies through the use of variables. In the simplified English grammar variables are prefixed by % signs. Variables are substituted for concrete values during evaluation. Enjoy...

using System;

using System.Collections.Generic;

using System.Text;

using Microsoft.Research.SecPal.Authorization;

using Microsoft.Research.SecPal.Parser;

namespace DeclarativeTest

{

class Program

{

static void Main(string[] args)

{

// Input policies

// 1. Policy restricting access to a resource to those principals possessing a valid email address

string resourceAccessPolicy =

"LA says %p can read digitalContent:'file://public/' " +

" if %p possesses %a" +

" where %a matches rfc822Name:'.*@microsoft.com' ";

// 2. Policy delegating the rights to an STS to make statements about possession of email attributes

string trustPolicy =

"LA says K-STS can say %p possesses %a" +

" where %a matches rfc822Name:'.*@microsoft.com' ";

// 3. Identity assertion that would normally be included inside a token when the user requests access to a resource

string identityPolicy = "K-STS says K-JAHOGG possesses rfc822Name:'jahogg@microsoft.com' ";

// Authorization Query

// Query created based on the specifics of the resource access request

string authzQuery = "LA says K-JAHOGG can read digitalContent:'file://public/foo.txt' ";

// Error - keyholder principals are getting recreated each time

Assertion a1 = Interpretor.parseAssertion(resourceAccessPolicy);

Assertion a2 = Interpretor.parseAssertion(trustPolicy);

Assertion a3 = Interpretor.parseAssertion(identityPolicy);

Assertion[] assertionList = new Assertion[3] { a1, a2, a3 };

AuthorizationQuery aq = Interpretor.parseAuthQuery(authzQuery);

Console.WriteLine("Authorization result");

// Make an authorization decision

IList<Answer> answers =

AuthorizationEngine.MakeAuthorizationDecision(new LocalAuthorityPrincipal(),

assertionList,

aq,

new List<AuditRule>());

Console.WriteLine("Answer was " + (answers.Count > 0));

}

Parser for SecPAL simplified English grammar now available!

Jason Hogg — Mon, 27 Aug 2007 00:17:00 GMT

One of the great strengths of SecPAL is its unique support for multiple representations of a security policy; XML for interoperability; and a simplified English grammar for human readbility. The SecPAL v1.1 Research Release (available from http://research.microsoft.com/projects/secpal) allows SecPAL assertions to be created using the rich and flexible.NET object model or deserialized from (or serialized into XML) XML according to the SecPAL Schema Specification (also available at the aforementioned URL).

We have now also created a sample parser that allows SecPAL policies and authorization queries to be specified using a simplified English grammar and then translated into the SecPAL object model. This allows policies to be specified declaratively in a human readable form. The parser is written using F# and uses the Lexx and Yacc tools that accompany F#. Full source code is included - so if you are looking for a good project to start learning F# - or if you want to see a complete parser implementation developed using F# and the accompanying tools then this is a great place to start.

I really enjoyed working on this sample as it gave me an opportunity to learn a lot more about F# - so over the next couple of posts I will share a lot more information on how the sample works including some tips about F# that I have learned. I will also start posting additional additional access control patterns specified declaratively - hopefully making the samples much easier to follow than the more length samples written purely in C# or F#.

The parser sample is available from here: http://www.codeplex.com/secpal/Release/ProjectReleases.aspx?ReleaseId=6667

Swiss Army Knife of X.509 Certificate Tools

Jason Hogg — Mon, 20 Aug 2007 20:31:00 GMT

Anyone who has dealt with X.509 certificates when trying to design, test and deploy secure Web services will know what an ordeal it can be to locate certificates in various cert stores using different cert identifiers, modify security properties of the private key to allow services accounts to sign or decrypt messages and all the other messing around that is associated with X.509 certificates. I happened to bump into Christian Geuer-Pollmann from the European Microsoft Innovation Center last week - and he showed me an awesome tool they have built to greatly simplify such challenges. This tool is available for download from here.

A Java implementation of SecPAL?

Jason Hogg — Thu, 09 Aug 2007 02:41:00 GMT

Panos, from the University of Newcastle just dropped me a note to say that he is making progress with his Java based SecPAL implementation - which is very exciting. I noticed that he has moved away from XSB and has decided instead to create his own custom datalog implementation - which is very cool - I am sure that took a coulple of very late nights! If you are interested in learning more take a look at Panos' blog.

The IEEE Computer Security Foundations Conference

Jason Hogg — Sun, 08 Jul 2007 03:43:00 GMT

The 20th IEEE Computer Security Foundations conference is underway in Venice at the moment, and our friends from Microsoft Research in Cambridge (Moritz Y. Becker, Cedric Fournet and Andrew D. Gordon) presented the first paper of the conference - based on their formal design for SecPAL. The paper "Design and Semantics of a Decentralized Authorization Language" is of course available from here. I have also included a photo of Moritz presenting which Andy just sent us.

Access Control Requirements for Grid Computing Environments

Jason Hogg — Tue, 03 Jul 2007 20:03:00 GMT

One question I hear a lot is "How does SecPAL compare with [InsertRandomSecurityTechnologyAcronymHere]?". Well the good news is that Marty Humphrey, Sang-Min Park, Jun Feng, Norm Beekwilder and Glenn Wasson from the Department of Computer Science at the University of Virginia have been studying just this question using real requirements from their grid network as the basis for this evaluation. The results of their study have been published in a paper called Fine Grained Access Control for GridFTP using SecPAL.

They have identified and categorized a number of requirements and then performed an in-depth analysis evaluating the extent to which SecPAL (and other security technologies) meet these requirements. They also consider six specific data access use-cases that have been problematic in today’s Grids: attribute-based access, role-based access, “role-deny” access, impersonation-based access, delegation-based access, and capability-based access and show actual SecPAL policies that they used to solve these use-cases.

One of the reasons why I think this paper is so important is that the UVa folks started their evaluation with a thorough understanding of their requirements - and documented them. So if you are in the process of evaluating a new access control solution (or perhaps building a custom access control solution) you will definitely gain by using the requirements in this paper as a starting point for your work.

All in all a really great paper - and the best news is that the paper has officially been accepted for Grid2007 - so if you are interested in hearing more hopefully you will be able to watch the presentation at Grid2007 in Austin Texas.

SecPAL Query Editor Now Available

Jason Hogg — Fri, 22 Jun 2007 01:40:00 GMT

A couple of people have remarked to us that they like the flexibility that SecPAL provides, but feel that it is difficult for people to get to grips with the API's when they first start evaluating SecPAL.

For this reason Lonnie Wall (a consultant from RDA Corp) has just released some sample C# source code for a SecPAL query editor and released it on our SecPAL CodePlex workspace. In addition to providing a GUI based interface to our samples*, the query editor also includes:

A series of task specific wizards for performing tasks such as establishing trust relationships, protecting resources and writing queries.
The ability to review security policies and tokens using our new simplified English grammar.
The ability to load / save your authorization context into XML based on our SecPAL Schema.
A graphical interface for reviewing query results - including direct access to the graphical proof graph viewer.
The ability to review the samples source code from within the editor.

The code is of course just sample, and although it only touches on the surface of SecPAL's capabilities I think it should hopefully provide a good starting point for people evaluating SecPAL. More importantly, it should also demonstrate one approach in which SecPAL could be integrated into products - hiding the complexity of our API's from end users.

The query editor functions best with our v1.1 release, so if you haven't already installed v1.1 download it from here. We are definitely looking for feedback, so if you have any comments / suggestions post them on the workspace. Also, if there are other examples of UI's that you like (or dislike) post some pointers to our workspace so other people can also comment.

* If you haven't had a chance to check our samples out yet - take this opportunity to review them. The samples include common access control patterns such as: establishing trust relationships, audit logging, unconstrained delegation (impersonation), constrained delegation, role exclusion, exists quantification, revocation, role based security, role exculusion, multi-level delegation, two man scenario, user and application scenario and much much more...

Writing SecPAL Assertions In F# - Contd

Jason Hogg — Wed, 20 Jun 2007 19:24:00 GMT

In my earlier post I showed how SecPAL could be used to grant access to a particular user based on a token issued by an STS that we explicitly established a trust relationship with using the SecPAL "canSay" predicate. Now I am going to show you something that I think is really cool - and something that demonstrates the advantage of our underlying Datalog engine. We are going to make three small changes to the code I showed you in the earlier post to demonstrate how instead of an authorization query being used to determine whether a particualr user can access a resource, we are going to ask who all the users are that can possibly access a resouce based on the policies we have defined.

This kind of query is simple for SecPAL. We simply change our authorization query from including a concreate value (LA says jason can read file://public/foo.txt) to a query that includes a variable (LA says %p can read file://public/foo.txt) at which point Datalog will evaluate what all the possible principals are that can read this resource and will then return a list of substitutions. In addition to the substitutions it will also include proof graphs for each possible substitution showing exactly why it is that a particular user could access this resource. Anyone who has used Prolog in the past will likely realize that this is similar to how Prolog works and this is in fact because Datalog is in a subset of Prolog!

Now before you run this code take a look at this and the original resource access policy and decide which of our users will in fact be granted access to read this file. Not all of them will be... and it should hopefully be obvious which one will not be granted access.

In order to make this change three pieces of code need to change:

1. Create additional users - We will create five additional users, four of which are actually the SecPAL developers, and the fifth is not.

// Define the users within the simple scenario
let User1 = KeyHolderPrincipal(new RSACryptoServiceProvider(), "John")
let User2 = KeyHolderPrincipal(new RSACryptoServiceProvider(), "Greg")
let User3 = KeyHolderPrincipal(new RSACryptoServiceProvider(), "Jason")
let User4 = KeyHolderPrincipal(new RSACryptoServiceProvider(), "Larry")
let User5 = KeyHolderPrincipal(new RSACryptoServiceProvider(), "Fred")

2. Issue tokens for the additional users - For this example I am being lazy and simply putting all the claims about possession of attributes in one token. In reality each user would normally be issued their own token.

// Create a Token to identify our Users with 
let token = Token(issuer=PrincipalIssuer(STS),
                  claims=[ Claim(fact=PossessFact(User1, 
                                                  new SecPALAttribute(AttributeType.rfc822Name,@"john@microsoft.com")));
                           Claim(fact=PossessFact(User2, 
                                                  new SecPALAttribute(AttributeType.rfc822Name,@"greg@microsoft.com")));
                           Claim(fact=PossessFact(User3, 
                                                  new SecPALAttribute(AttributeType.rfc822Name,@"jason@microsoft.com")));
                           Claim(fact=PossessFact(User4, 
                                                  new SecPALAttribute(AttributeType.rfc822Name,@"larry@microsoft.com")));
                           Claim(fact=PossessFact(User4, 
                                                  new SecPALAttribute(AttributeType.rfc822Name,@"fred@hotmail.com")))
                                                  ]) 

let tokens = [ token ]

3. Modify our authorization query - We now change the authorization query so that we leave a variable in the query. SecPAL will then determine all the valid users are for this this variable can be unified.

// Create our Authorization Query 
//		LA says %p can read file://public/foo.txt?
let query = AuthorizationQuery
               (expression=AssertionExpression
                   (assertion=AtomicAssertion
                       (principal=ResourceGuard, 
                        fact=ActionFact(PrincipalVariable("p"), ActionVerbs.read, 
                                        Resource(ResourceType.digitalContent, 
                                                 System.Uri(@"file://public/foo.txt"))))))

Writing SecPAL assertions in F#

Jason Hogg — Sat, 16 Jun 2007 02:22:00 GMT

I figured I would try to learn F# over this summer - and thought what better way to start than create a couple of SecPAL samples in F#. I thought this might help people that are interested in learning more about F#, or potentially F# users that are interested in learning more about how SecPAL can be used for access control scenarios. The sample below is simplified version of our classic multi-domain scenario (see here for a complete description). In short we have three parties: A resource guard that is responsible for protecting access to a resource, an STS that is trusted to issue claims about users, and a user that wants to access a file.

In order to support this scenario we have the following assertions:

SecPAL policies

Resource access policy - LA says %p read file://public/ if %p possesses %a where %a match .*@microsoft.com
Trust policy - LA says STS canSay %p possesses %a where %a match .*@microsoft.com

SecPAL token

STS says User possesses rfc822Name:jason@microsoft.com

SecPAL authorization query

LA says Jason can read file://public/foo.txt?

When run the code will output a textual proof graph illustrating exactly what the chain of deductions were that lead to this authorization decision being approved. If you want to use our graphical proof graph viewer take a look at this post. You will have to add an audit policy but that is really straight forward.

The F# code for this scenario is included below. In the my next few blog posts I will show you how to modify this code to do some extra cool things... In the mean time let me know if you have any questions, or if there are any scenarios you would like me to demonstrate.

Thanks to Don Syme and Can Erton of the F-Sharp team for reviewing my code before I released it!

// Title: Simple SecPAL security scenario (F#)
#light
// Update the pointer below to your SecPAL DLL (The SecPAL .NET implementation is available from http://research.microsoft.com/projects/secpal)

#I "C:\Users\jahogg\Documents\Microsoft SecPal Research Release\Bin\Microsoft.Research.SecPal.dll"
#r "Microsoft.Research.SecPal.dll"

open Microsoft.Research.SecPal.Authorization 
open System.Security.Cryptography
open System.Collections.Generic
type SecPALAttribute = Microsoft.Research.SecPal.Authorization.Attribute

// Define the users within the simple scenario
let User = KeyHolderPrincipal(new RSACryptoServiceProvider(), "Jason")
let STS = KeyHolderPrincipal(new RSACryptoServiceProvider(), "STS")
let ResourceGuard = LocalAuthorityPrincipal("ResourceGuard") // ResouceGuard == LocalAuthority == LA

// Define Resource Access Policy 
//		LA says %p read file://public/ if %p possesses %a where %a match ".*@microsoft.com" 					
let claims = [Claim(fact=ActionFact(PrincipalVariable("p"),
                                    ActionVerbs.read,
                                    Resource(ResourceType.digitalContent,
                                             System.Uri(@"file://public/"))),
                    condition=PossessFact(PrincipalVariable("p"),
                                          AttributeVariable("a")),
                    constraint=AttributeMatchConstraint("a",AttributeType.rfc822Name, @".*@microsoft\.com"));
              // LA says STS canSay %p possesses %a where %a match ".*@microsoft.com" 					
              Claim(fact=CanSayFact(STS,
                                    fact=PossessFact(PrincipalVariable("p"),
                                                     AttributeVariable("a"))),
                    constraint=AttributeMatchConstraint("a",AttributeType.rfc822Name, @".*@microsoft\.com")) ]

let policy = Policy(PrincipalIssuer(ResourceGuard), claims)
let policies = [ policy ]

// Create a Token to identify our User with 
//		STS says User possesses rfc822Name:"jahogg@microsoft.com"
let token = Token(issuer=PrincipalIssuer(STS),
                  claims=[ Claim(fact=PossessFact(User, 
                                                  new SecPALAttribute(AttributeType.rfc822Name,@"jason@microsoft.com")))]) 

let tokens = [ token ]

// Create our Authorization Query 
//		LA says Jason can read file://public/foo.txt?

let query = AuthorizationQuery
               (expression=AssertionExpression
                   (assertion=AtomicAssertion
                       (principal=ResourceGuard, 
                        fact=ActionFact(User, ActionVerbs.read, 
                                        Resource(ResourceType.digitalContent, 
                                                 System.Uri(@"file://public/foo.txt"))))))

// Perform our Authorization Query using the Authorization Engine		
let answers = AuthorizationEngine.MakeAuthorizationDecision(ResourceGuard, tokens, policies, query) 
 
// Determine if access was granted
let results = (if (answers.Count < 1) then "Denied" else "Authorized") 

// Print out the results
printf "The result is %s \n" results
printf "Answer count = %i \n\n" answers.Count

// Iterate over the Proofs
for answer in answers do
    // Output variable substitutions
    let subs = answer.Substitution 
    for sub in subs do
        System.Console.WriteLine ("Name " + sub.Key.Name + " = " + sub.Value.ToString());
    // Output proof graphs
    let proofs = answer.ProofGraphs 
    for proof in proofs do
        System.Console.Write("Expression = ")
        System.Console.WriteLine(proof.Expression)
        System.Console.WriteLine("Graph = ")
        System.Console.WriteLine(proof.ProofRoot)

// Press any key to continue (Homer "Where's the any key?")
System.Console.ReadLine()