(00:30) Jon McCoy overviews his NDC talks, explaining how he got into security and some of the amazing things he’s found out about .NET about along the way, like using Java JARs inside .NET applications.
(02:55) Jon McCoy says that understanding IL and how the JIT works allows him to directly use assembly code and C++ from within .NET applications.
(03:45) K Scott asks Jon McCoy about some of the tools he showed during his talks. Gray Dragon is a memory injection program which allows injecting code and remapping while an application’s running. Gray Wolf allows editing an application’s IL code. In his talk, he demonstrates extracting his admin password from biometrics password with six clicks.
Developer security practices: obfuscation, unit tests, monitoring
(05:20) Jon G asks if obfuscation helps hide his code. Jon McCoy says it’s always reversible and there’s about a three month lag between obfuscator releases and workarounds. Just about anything that can be automated can be reversed.
(06:44) Jon McCoy recommends security unit tests for practices like SQL cleaning and throwing security exceptions. Monitoring for security exceptions will let you know someone’s attacking you – if someone has two years to attack you without you knowing, they’re going to get in.
(07:42) Attackers can target update mechanisms in desktop programs to target users throughout your enterprise. Also, the nature of .NET code makes it very difficult for antivirus software to detect when it’s doing something bad.
(08:30) Jon McCoy says there’s a security issue with Visual Studio in that it executes constructor code for controls as they’re loaded in the designer, so a malicious user can run code which runs under your user permissions.
Securing information on your computer: crypto and passwords
(09:40) Jon McCoy talks about some of the security practices he recommends: full disk crypto with TrueCrypt, using a hardware solution like YubiKey for long passwords, and using encrypted VMs as secure containers.
(11:12) Jon G asks Jon McCoy what he thinks of solutions like Keepass and LastPass. K Scott asks whether OpenID and OAuth help. Jon G laments that CardSpace never took off.
(12:47) Jon G asks if signed code helps secure code at all. Jon McCoy says it doesn’t really, since it’s not validated.
Businesses and security
(13:27) Jon G asks if Jon McCoy gets involved with forensics. Jon McCoy says he mostly works with small businesses who are being attacked or want to fix security issues.
(14:31) K Scott asks Jon McCoy if he deals with mobile device security. Jon McCoy discusses the security blind spots desktop and mobile developers have.
(15:23) Jon G asks what Jon McCoy thinks about two factor auth.
(16:22) Jon McCoy explains how his background as a developer helps him understand issues in a way that IT focused security experts don’t.
Defending against cracks
(17:20) Jon asks about defense against cracks. Jon McCoy says the motivation behind cracks and malware shifts – sometimes the bad guys are just after a proxy network, password cracking machines, or even free cloud storage. Malware distributors can really strike it rich by owning a computer that happens to be inside a big company; they can sell that access for a lot of money. Part of fighting an attack is understanding what’s motivating the attacker.
(19:07) Jon G talks about targeted attacks against employees using fake, infected PDF business documents – send to enough people and a few will open it. Jon McCoy says that’s why he advocates using a hardened VM for browsing the internet as well as using different e-mail addresses so you know unsolicited e-mails to an admin e-mail can’t be valid.
Resources: tools and papers
(20:13) Jon G asks for a little more information about the security tools Jon McCoy distributes on his site.
(20:47) Jon G asks about how Jon McCoy’s security disclosure policies. Jon McCoy says he generally keeps things secret long enough to give his clients a security advantage. He talks about a technique he used which phones home when obfuscated code is decompiled.
(21:51) Jon G asks Jon McCoy how he keeps up with things. Jon McCoy says things are pretty lonely, he’s off on his own most of the time. Jon G says it’s easy to forget that a lot of .NET runs on top of Win32 and COM.
(23:10) Jon G asks Jon McCoy for some reference for developers who are interested in learning more. Jon McCoy lists a few (referenced in the show links).
(00:17) K Scott asks Dominick about the subject of his talk at NDC. Dominick runs through the upcoming changes in Web API authentication, including an overview of CORS and token based authentication.
(03:49) Dominick explains the ability to support a separate token server in Web API and announces Authentication Server, his new open source project which provides
(05:13) Rob describes how he’s seen people breaking their sites and services across multiple domains and subdomains. He explains a problem he’s currently running into with older releases of Internet Explorer. Dominick explains more about how CORS works and talks about options for working with older browsers – either sticking with JSONP or putting services in the same domain.
(08:15) Jon asks how security token service relates to more well-known terms like OpenID and OAuth. Dominick explains some of the history and challenges OAuth has encountered. As a result, the OAuth spec is really just a collection of patterns rather than a strict specification.
(11:19) Jon asks Dominick how he implemented the OAuth spec in his Authentication Server implementation. Dominick gives examples of how the spec is very open – for instance, there are 69 occurrences of the word MAY in the spec. He says he’s been advocating for a minimum profile.
(12:56) K Scott asks what sort of authentication should be used with Dominick’s security token server, since OAuth isn’t an authentication mechanism. Dominick explains the interaction with security tokens.
Token based security and JWT
(14:49) Jon comments on the difference in security implications between a compromised token vs. a compromised account password. Dominick says that a token binds five things together: the client, a human, an application, permissions and time. He mentions that with token based authentication you can outsource the security mechanism – passwords, certificates, etc. – and talks about the newly released JSON Web Token (JWT) handler.
(15:50) K Scott asks for some specifics about the JWT handler.
(16:27) K Scott asks for more information about Dominick’s talk.
Roles vs. Claims
(17:14) Jon asks about the difference between roles and claims. Dominick explains that a role is just a very simple claim: are you in a role or not? Claims move from a simple boolean to more of a name / value pair
(18:31) Jon asks what the average developer needs to know about Windows Identity Foundation.
Photography and wrap-up
(19:02) K Scott asks Dominick about the photos section on his site and comments on how they’re just about all black and white. Dominick
(20:52) K Scott asks Dominick what he’s got coming up. Dominick says he’s been heads down on the Authentication Server release.
(00:32) Paul gave a talk on Windows infrastructure management with Puppet and PowerShell. Puppet is a configuration management tool. It allows you to define a configuration management level, and Puppet will bring it to that level and keep it there.
(01:05) K Scott asks Paul how this relates to his continuous deployment emphasis. Paul explains how this has been part of the maturity model they’ve been using at his employer, Open Table.
(01:50) Paul explains how they started using Puppet in their pre-production environment of 19 VMs. Their production environment is four times that large.
Some more questions about Puppet
(03:00) Jon asks how Vagrant and Chef fit in. Paul explains how Puppet, Chef and CFEngine relate.
(04:07) K Scott asks if it’s worthwhile to look at Puppet in a small environment with 2-3 servers. Paul says there’s an investment, so you really start seeing the rewards as things start getting more complex.
(05:01) K Scott asks how you define a state.
(06:30) K Scott asks about the client running on the target servers.
(06:51) Jon asks how the verification works.
(07:32) Jon asks if it’s possible to use Puppet in cloud environments.
(07:56) K Scot asks if you can use Puppet to configure developer workstations. Paul talks about GitHub’s Boxen system. Jon talks about his experiences looking at Boxen before settling on sprout-wrap.
(09:21) Paul mentions that Open Table just open sourced their Puppet IIS implementations.
How Puppet relates to PowerShell and Chocolatey
(09:36) Jon asks what the PowerShell tie-in is, since Puppet is all Ruby based. Paul talks about the PowerShell scripts they exec from Puppet and how they use them to do things like turn Windows features on and off.
(11:01) K Scott asks if you could use Chocolatey with Puppet, and Paul says they’re using Chocolatey via PowerShell. Jon says that sounds useful since Chocolatey can now integrate with the Web Platform Installer, and Paul says they’re doing just that to install .NET 4 on their servers.
More questions about Puppet
(11:47) Paul talks about how traditional infrastructure management runs on documentation, and how they can replace all of that using Puppet.
(12:58) K Scott asks if this is also useful for deployments. Paul says a deployment is just a different configuration state, so Puppet can handle that just fine.
(14:09) Jon asks if Puppet can handle database state.
(14:50) Jon asks how you handle licenses with Puppets.
(15:20) Jon asks how Puppet relates to Windows configuration management options. Paul says that at Open Table they’ve moved to using multiple platforms, so they need infrastructure management options that can work across all of those environments.
(16:30) K Scott asks what is was about Puppet that caused him to lose some hair. Paul says it’s scary to be able to write a module that makes changes to 90 servers.
And some more Puppet stuff
(17:30) Jon asks if it’s possible to do automated testing with Puppet configuration and modules.
(18:27) K Scott asks if there’s any kind of rollback plan for Puppet.
(18:40) K Scott tries to ask Paul about what he does in his free time, but Paul says in his free time he writes code and changes the subject back to Puppet.
(19:21) Paul says he’s going to be speaking at Puppet Conf, so he’ll be speaking at a Linux administrator’s conference.
(20:00) K Scott asks if there’s political fallout from systems administrators who are concerned he’s trying to replace their jobs. Paul says he’s trying to free them up from repetitive tasks in their jobs so they can get more done.
(20:56) K Scott asks Paul about upcoming conferences he’s going to be speaking at.
(00:40) Rob asks Laurent how often customers ask for HTML/JS based Windows Store application rather than XAML based. Laurent lists a few of the cases where people ask for HTML based work, but says the cases are very rare. Generally they’re much more productive with XAML and C#.
(02:49) Rob asks Laurent if he thinks this will change over time. Laurent says IDE support may affect things a little, but generally he thinks web developers don’t do desktop development because they don’t want to do desktop development – they went into web development because they wanted to develop for the web.
(04:09) Jon asks if Laurent sees things changing over time in XAML based development. Laurent says he sees some big changes in performance – you can get good performance out of the native controls with full designer support now. In terms of Windows 8, he’s hoping for more controls to cover some Windows 8 UI elements so they don’t require custom controls. In terms of design, he sees some cases where people are breaking some of the general Windows Store design guidelines in cases where they aren’t as user friendly. Jon says he’s seen one example of this – adding a print app bar button to applications where printing is a regular activity, even though technically the print is supposed to be accessed via the share charm. Laurent says he also sees this in search-heavy apps.
Cross-platform code sharing and Portable Class Libraries
(07:46) Jon asks about Laurent’s talk on sharing code between platforms – does it work? Laurent says he’s focusing on portable class libraries – writing logic that works on Windows Phone and Windows Store, then building a UI on top of those libraries. That’s working well for him and he’s using it in production. It’s still XAML and C#, so you can also share code, too.
(09:26) K Scott asks about MVVM Light – is that working with Portable Class Libraries? Laurent says someone at Microsoft use a PCL port of MVVM Light as a test case, and it’s working very well. They still maintain platform specific versions of MVVM Light for people who only work on a specific platform.
(10:38) K Scott asks for a quick summary of what MVVM Light does.
(12:45) K Scott asks about some of the challenges in converting MVVM Light to a PCL. Laurent talks about some UI and platform differences.
Metro and modern design
(14:21) Rob asks how you make different design decisions around “Metro” design or other alternatives. Laurent discusses the design process.
(16:29) Rob asks about some of the design considerations, and how you’d decide on platforms. Laurent says a default XAML application uses themes which will fit in with the host platform and operating systems, but might look at bit boring, which is why you work with a designer.
(18:25) Jon says the Windows Store design principles don’t prescribe a boring look, referencing the “alive with color” thing and Kelly Sommers’ post about how Metro Doesn’t Have To Be Boring. Laurent says he doesn’t like the “flat design” term, preferring modern – and modern came from Bauhaus in the 1920′s, Swiss design in the 1950′s, etc. He says it’s important to go the design principles, then use your skill as a designer to apply that. There are enough apps on the Windows Phone store that getting noticed takes a good design.
(22:09) Rob asks Laurent what he does for hobbies. Laurent lists some things that keep him busy, then talks about his fish pond. Rob tells probably the worst newt joke of all time.