Edify Friday: Parallel Computing in .NET 4.0 with PLINQ

The Institute for Cyber Security uses C# and the .NET Framework for our startups in incubation, internal research projects, community exercises, and more. With the second beta of Visual Studio 2010 out, we've been really interested in the framework and language changes, and are evaluating it for integration into our software process. One change in particular is PLINQ, which stands for Parallel Language Integrated Query. This builds on LINQ, introduced two years ago, which added native data querying capabilities to .NET languages. Thus, today's Edify Friday covers a simple way to use PLINQ in C# code.

First, let's take a look at a simple LINQ example. Below is a simple program that counts the number of even numbers up to a ceiling (see Listing 1 below):

using System;
using System.Linq;
using System.Collections.Generic;
using System.Diagnostics;

namespace PlinqExample {
  class HelloWorldPlinq {
    static void Main(string[] args) {
      Stopwatch sw = Stopwatch.StartNew();
      int numEven = CountEven(1000000);
      Console.Write("Found {0} even numbers. ", numEven);
      Console.WriteLine("Elapsed: {0} ms", sw.ElapsedMilliseconds);
    }

    private static int CountEven(int top) {
      IEnumerable<int> allNumbers = Enumerable.Range(1, top);
      var q = from i in allNumbers where (i % 2 == 0) select i;
      return q.Count();
    }
  }
}

Listing 1: HelloWorldPlinq.cs

When running the application, one should get something similar to the following: "Found 500000 even numbers. Elapsed: 18 ms." (naturally, the elapsed time will vary based on CPU power and processor availability).

Now, we'll modify one line from above to make use of PLINQ (see Listing 2 below):

private static int CountEven(int top) {
  IEnumerable<int> allNumbers = Enumerable.Range(1, top);
  var q = from i in allNumbers.AsParallel() where (i % 2 == 0) select i;
  return q.Count();
}

Listing 2: Partial Listing of HelloWorldPlinq.cs

By using the AsParralel() method, we effectively cast q as a different object entirely that can take advantage of threading for its calculations. Now running the application may give you something similar to the following: "Found 500000 even numbers. Elapsed: 14 ms."

Got a topic that you'd like to see covered in Edify Friday? Leave a comment below or email me!

Erhan J Kartaltepe, PMP
erhan.kartaltepe-at-utsa.edu

Edify Friday: Death Star Threat Modeling

The Institute for Cyber Security, as one may suspect, deals with security issues on a daily basis. Whether it's with our startups in incubation, internal research projects, presentations at conferences, or something else entirely, security vocabulary is used to describe very specific situations. When using terms like "vulnerability" or "threat", which have precise meanings in an information security context, it helps when everyone is on the same page with the vocabulary. Thus, today's Edify Friday covers threat modeling at a high level, with an object lesson at the end:

• An asset is a resource of some value. This value could be real or perceived, and could be different from the owner and the attacker.
• A vulnerability is a weakness that could be exploited to harm the asset. This could be unintended, like a software bug, or intended, such as an assumption that the vulnerability is unlikely to be exploited.
• A threat is something that can harm the asset, usually by exploiting the vulnerability. The intent of the threat is irrelevant, and could be man-made, automated, or natural.
• A risk is the likelihood that the harm will occur. Risk is present in any system, and is a function of an asset's value, the vulnerability's severity, and threat's probability.
• A countermeasure is a control that reduces risk to some level. This must be balanced against the risk probability and the asset's value.

Put another way, risk is the chance that a threat will attack or exploit a vulnerability. My favorite view of this is the "Death Star Threat Model" (shamelessly translated from Kevin William's presentation last year at the Last Hope conference). Here, the asset was the Death Star; the vulnerability of the Death Star was the two meter-wide thermal exhaust port that's shaft lead directly to the reactor system; the threat to the Death Star was the Rebel Alliance's X-wing star-fighters; the risk was the slim chance that a small one-man fighter could penetrate the outer defenses, use a proton torpedo to score a precise hit, and start a chain reaction that will destroy the battle station; and the countermeasure was a deployment of Imperial tie fighters around the Death Star.

That's threat modeling in a nutshell.

Got a topic that you'd like to see covered in Edify Friday? Leave a comment below or email me!

Erhan J Kartaltepe,
erhan.kartaltepe-at-utsa.edu

Edify Friday: Python and .NET Interoperability

At the Institute for Cyber Security, we use develop mobile applications and use Python and .NET Framework for our startups in incubation or in‐house projects, and every once in a while, we need to have them interoperate.

Today's Edify Friday covers how simple it is to use .NET code, either in the framework or in-house, in a Python application. It makes use of the Python ctypes library, allowing one to call functions in DLLs. In the example we walkthrough, we call the MessageBoxA function from WinDLL.

First, we "import" the libraries and Windows types we need. The function prototype WINFUNCTYPE is Windows-only; there are others for Python and C. Next,for ease of use, we're going to create a prototype of the MessageBoxA function, where the first parameter is the return type (MessageBoxA returns an integer) and the remaining parameters mirror MessageBoxA's parameters.

After we create the prototype, we can set named parameters in the usual Python style, giving default values for them if we like. Finally, we'll save this prototype to a variable (think delegates from .NET) we call MessageBox, giving it the class MessaBoxA belongs to, and its parameters.

The example below puts it all together in Python 3.1:

Figure 1: Windows Message Box in Python

Got a topic that you'd like to see covered in Edify Friday? Leave a comment below or email me!

Erhan J. Kartaltepe,
erhan.kartaltepe-at-utsa.edu

Edify Friday: Introduction to MonoTouch Development Using the OpenTK Package

We at the Institute for Cyber Security develop mobile applications and use the .NET Framework with for startups in incubation and our in‐house projects, so when MonoTouch was released last week, it seemed like the perfect marriage of those skill sets. Naturally, as we learned more about it, some things were straightforward and other things left us wanting to learn more. This seemed like the perfect time to introduce a new feature to the ICS Blog: Edify Friday, where we'll take a topic related to cyber security, application development, or technology startups and flesh out a walkthrough or tutorial.

Today's Edify Friday is in whitepaper form and covers how to use the OpenTK package for MonoTouch deployment (click here to read).

Got a topic that you'd like to see covered in Edify Friday? Leave a comment below or email me!

9/28/2009 Update: The whitepaper has now been updated to include a second example using the iPhoneOSGameView class, which greatly simplifies graphics programming. An animation example is now included.

Erhan J. Kartaltepe,
erhan.kartaltepe-at-utsa.edu