If you want to get past this, first thing’s first: cancel it, as it’s not going to go anywhere.

After stopping the install open up your registry and find the following DWORD value:

HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows NT\Terminal Services\TSAppSrv\TSMSI\Enable

Some of the keys in the path may not exist, if you run into any that don’t exist just create them. Once you have found the Enable DWORD value, make sure it is set to 0.

Now start the JDK installer up again and you should be able to install with no problems!

To fix this try running the game in windowed mode instead of full screen mode until the cut scenes has finished and then switch back to full screen mode to continue playing as normal.

If this doesn’t work for you some people have suggested the following (though this did not work for me):

1. Exit the game
2. Right click Hitman: Absolution in Steam and click properties.
3. In the window that appears click the Local Files tab
4. In the Local Files tab click on the third button down, labelled “Verify Integirty of Game Cache…” (see below).

As I had to add this functionality, I have created an extension of the TextBox control for everyone to freely use, the source code of which you can find at https://github.com/intninety/temporaltextbox. This post is essentially just giving an overview of it and an example of how to implement it.

For anyone not interested in the summary and implementation explanation that just wants to skip straight to the actual code of the extended class, you can find it here: https://github.com/intninety/temporaltextbox/blob/master/TemporalTextBox/TemporalTextBox.cs

What version of .NET is this compatible with?

As of the time of writing this, it requires 3.5 or later. It is possible to rewrite it to work with 2.0 if you do want to, you’d just have to replace the use of LINQ in the Transform method.

What is better about the undo functionality in TemporalTextBox?

Unlike the standard TextBox, TemporalTextBox will allow you to undo every operation as far back as it being initialised as opposed to only being able to undo the very last operation.

How do I implement it?

The first thing you’ll need to do is grab a copy of the source code from https://github.com/intninety/temporaltextbox.

If you decide to build the DLL from the project then add a reference to it into your own project. Alternatively if you want to include the source code directly in your project, then make sure you add a reference to LINQ.

Once you’ve got the TemporalTextBox reference or class in your project we can get started on implementing it!

To use the control you can either add it via the Toolbox as you normally would in the designer, or you can use the Transform method. The Transform method will consume a standard TextBox and set all the properties of your TemporalTextBox to be the same, allowing it to seemlessly take the place of the one you have already designed your form with.

If you want to try out the transform method then add a standard TextBox control onto your form and tweak it as you want. Now switch to the code view and add a new instance member of type TemporalTextBox. Once in the code view add the following code in the Shown event of your form, replacing temporalTextBox with the name of your TemporalTextBox instance, and textBox1 with the name of your standard TextBox.

this.temporalTextBox = new TemporalTextBox();
this.temporalTextBox.Transform(this.textBox1, true);
this.Controls.Add(this.temporalTextBox);

And voila, you now have your TemporalTextBox on your form and are now ready to utilise the undo and redo methods!

Using these doesn’t really require much explanation, simply call the Undo method to undo an operation, and call Redo to redo a previous undo operation; it’s that simple…

If you don’t want to use the improved undo functionality I mentioned previously that is in TemporalTextBox you’ll just have to make sure you set the UseCustomUndoMethod property to false. This will have no effect on the redo functionality  you’ll still be able to use the redo method even if using the standard undo method.

How are strings pushed to the undo and redo stacks?

Unless you’re interested in how the undo and redo methods are implemented behind the scenes, you may want to skip this section!

The current text (prior to the key press) is pushed onto the undo stack every time the user presses one of the following keys:

• Backspace
• Delete
• Enter
• Space

In addition to this, when the text is changed it checks to see if the difference between the previous text and the new text is more than a character long, if it is then we push to the stack again (as this would imply a paste operation). If we only have one character then we don’t push to the stack as we don’t want undo operations to be on a per-character basis. If the length of the two strings are equal, then this would imply that we have had a paste operation over an existing piece of text, so we check to see if the strings are also equal, and if they aren’t we push to the stack.

The redo stack is simply pushed to every time we make a call to the undo method.

The CultureInfo class has two private static members named m_userDefaultCulture and m_userDefaultUICulture in versions prior to .NET 4.0; in 4.0 they are named s_userDefaultCulture and s_userDefaultUICulture.

These two members are used when calling Thread.CurrentThread.CurrentCulture and Thread.CurrentThread.CurrentUICulture, and with some simple reflection we can set these members, and all calls from there on to these two properties will return our newly set default.

Copy and paste the method below into your project wherever you see fit, ensuring that you are using both System.Globalization and System.Reflection at the top of the file:

public void SetDefaultCulture(CultureInfo culture)
{
    Type type = typeof(CultureInfo);

    try
    {
        type.InvokeMember("s_userDefaultCulture",
                            BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Static,
                            null,
                            culture,
                            new object[] { culture });

        type.InvokeMember("s_userDefaultUICulture",
                            BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Static,
                            null,
                            culture,
                            new object[] { culture });
    }
    catch { }

    try
    {
        type.InvokeMember("m_userDefaultCulture",
                            BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Static,
                            null,
                            culture,
                            new object[] { culture });

        type.InvokeMember("m_userDefaultUICulture",
                            BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Static,
                            null,
                            culture,
                            new object[] { culture });
    }
    catch { }
}

Just to give a slight overview of what is happening in that method re. the try catch blocks – as mentioned previously, the names of these static members differs between .NET 4.0 and versions prior, so this will attempt to set both and fall back to whichever one it needs.

Once you’ve added the method, simply call it and pass through the CultureInfo you wish to be the default and you’re done!

Below is a full example of how it can be used, or alternatively you can Download This Sample Project.

Enjoy!

using System;
using System.Globalization;
using System.Reflection;
using System.Threading;

namespace DefaultCultureInfoExample
{
    class Program
    {
        static void SetDefaultCulture(CultureInfo culture)
        {
            Type type = typeof(CultureInfo);

            try
            {
                type.InvokeMember("s_userDefaultCulture",
                                    BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Static,
                                    null,
                                    culture,
                                    new object[] { culture });

                type.InvokeMember("s_userDefaultUICulture",
                                    BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Static,
                                    null,
                                    culture,
                                    new object[] { culture });
            }
            catch { }

            try
            {
                type.InvokeMember("m_userDefaultCulture",
                                    BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Static,
                                    null,
                                    culture,
                                    new object[] { culture });

                type.InvokeMember("m_userDefaultUICulture",
                                    BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Static,
                                    null,
                                    culture,
                                    new object[] { culture });
            }
            catch { }
        }

        static void Main(string[] args)
        {
            Console.WriteLine("Culture name before update: {0}", 
                              Thread.CurrentThread.CurrentCulture.Name);

            SetDefaultCulture(new CultureInfo("fr-fr"));
            Console.WriteLine("Culture name after update: {0}", 
                              Thread.CurrentThread.CurrentCulture.Name);

            Console.ReadLine();
        }
    }
}

There are a few things in this guide that I’m not going to cover (such as rooting your device, the ins and outs of WireShark etc.), however I’ll add links to appropriate reading material for these things where I can! And if you’re still stuck feel free to ask for help in the comments.

Why not just use tcpdump on the pineapple itself?

The reason I ended up trying to do this is due to the fact that the pineapple only has the one USB port, and I don’t have a powered USB hub, so I thought – “Hey, why not just capture the traffic on my phone seeing as it’s tethering to the pineapple anyway?”.

In addition to not requiring a USB hub, it also has the benefit of not soaking up more battery power from the pineapple itself as it doesn’t have to power a pen drive and write data to it constantly.

What do we need to get started?

• A WiFi Pineapple MKIV, available from The HakShop
  I’d recommend the elite bundle for the extra goodies and as a means of helping support the project!
• A rooted Android device with the Shark for Root app installed
• A program capable of viewing pcap files. For this example I’ll be using WireShark

N.B. I should point out, at this point in time I am using version 2.6.1 of the firmware, which supports Android tethering without much extra configuration. If you are using an earlier version you may need to follow This Guide by wiregr.

Setting up the Pineapple

First thing’s first, power up your pineapple and give it a few minutes to finish booting. After it’s booted and ready to go, plug in your Android device via USB as in the picture below and enable USB tethering from your settings menu. The location of the tethering option can vary from device to device, but on my Samsung Galaxy S2 it can be found in Settings > Wireless and networks > Tethering and portable hotspot > USB tethering.

Give this a moment to begin tethering and then connect to the pineapple, either by Ethernet or by WiFi. Once connected to the pineapple network, SSH into the device (default credentials are root:pineapplesareyummy) and attempt to ping Google or any other external address to ensure that the Android device is indeed tethering to the pineapple.

Once we know the Internet connection from the Android device is definitely tethered to the pineapple, we need to configure iptables to route the traffic from the connected clients via the usb0 interface. You can either do this via the SSH session we have open, or by logging in to the pineapple’s web control panel and copying and pasting the commands into the “Execute Commands” box in the advanced tab.

The commands you need to execute are:

iptables -t nat -A POSTROUTING -s 172.16.42.0/24 -o usb0 -j MASQUERADE
iptables -A FORWARD -s 172.16.42.0/24 -o usb0 -j ACCEPT
iptables -A FORWARD -d 172.16.42.0/24 -m state --state ESTABLISHED,RELATED -i usb0 -j ACCEPT

This will have to be done every time you restart the pineapple, however you could throw it in a script if you wanted and make it run automatically on startup if you so wish.

N.B. At the time of writing this, the iptables configuration is necessary, however I believe that the Jasager team have plans to make this automatic in the future.

Setting up the Android Device

Now that our pineapple is setup and ready to go, we need to setup the Android device to capture traffic (this is much simpler than you may think).

As mentioned in the first section, your Android device must be rooted in order to run the app we need to capture traffic. As rooting devices is a topic (and in some cases challenge) of its own, I’m not going to go over it here. If you do need to root your device though, I’d recommend checking out This Guide at XDA-Developers. I have tested it, it works, and is about the fastest way you could root your device!

Now, the only thing we need for this step is an app available from the Google Play Store which is called Shark for Root, developed by Elviss Kuštans. You can download Shark for Root free from the following page: https://play.google.com/store/apps/details?id=lv.n3o.shark&hl=en

Capturing the Traffic

Once you’ve installed it, open it up and if presented with a screen asking your permission for it to use root access go ahead and accept it. The screen you’ll be presented with is pretty straight forward, there is a parameters input field which will let you specify the parameters you want to pass through to tcpdump (leave this as it is if you’re not familiar with it).

When you’re ready to begin monitoring the traffic hit the button labelled “Start” and the status should change to “Running”, with some information about the data it is capturing.

Now head over to another device that is connected to the pineapple and navigate to Google and search for something (for this example I’m going to search for “herpy derp derp”). Once the page has loaded you can go back to your Android device and click the stop button. After stopping Shark, make sure to take note of the filename so you know which file you are going to be working with.

Examining the Captured Data

I’m not going to go into much depth here as again examining network captures is a topic of its own, and if you’re up to this point you probably know what to be doing with a pcap file anyway.

Plug your Android device into your computer and copy over the pcap file that Shark exported to in the previous step, and open it up in WireShark.

What you see now is all the data that passed through the pineapple to the Android device, and anything else that the phone was doing on the network it was connected to.

If you want to filter this down to HTTP traffic, type “http” in the filter field and hit enter. As you can see in the screenshot below, the Google search for “herpy derp derp” was successfully captured.

The Covering My Ass Section

It goes without saying that to be doing this on a public network without the users’ permission is illegal due to the fact you can capture sensitive data via these means such as login credentials. If you’re going to do this and don’t want to have your hands slapped in the process, do it with your own devices or seek permission from people first who’s data you’ll be capturing.

If you are going to insist on doing this in public (which again, I am not encouraging!), at least don’t be an ass hat about it by screwing around with any personal data you may find; play nice!

Any questions or problems encountered? Feel free to post them!

The Problem

I have a WebBrowser control which navigates to about:blank and then loads HTML into the document from an embedded resource and then is altered afterwards to show incoming data. As this document is being built in real time, it causes issues when the user hits the F5 key, as it refreshes about:blank and shows them a blank screen again.

My initial solution to this was to just set the WebBrowserShortcutsEnabled property to false, gave it a test, it stopped it refreshing, all was good with the world again! Or not…

The WebBrowserShortcutsEnabled property will also disable CTRL+C and CTRL+V, although I don’t need the paste shortcut, I do need the copy shortcut.

The Solution

The solution is actually very simple, and I’m not sure why it took so long to come to the conclusion (I blame lack of Red Bull flowing through my veins!). But again – in case anyone is banging their heads against their desk, this is what you need to do:

Set the WebBrowserShortcutsEnabled property to false as previously mentioned and create an event handler for the PreviewKeyDown event of the WebBrowser control and add the code below to it

if ((e.Modifiers == Keys.Control) && (e.KeyCode == Keys.C))
{
    webBrowser1.Document.ExecCommand("Copy", false, null);
}

If you need to add more functionality back (i.e. cut and paste), the ExecCommand method also accepts Cut and Paste as commands, so just repeat the code above to pick up the X and V keys too and execute the appropriate command.

Additional Step

If also like me, you need to stop the user from navigating to another page from within your WebBrowser control, add an event handler for the Navigating event of your WebBrowser control and add the following:

if (!e.Url.ToString().Equals("about:blank"))
{
	System.Diagnostics.Process.Start(e.Url.ToString());
	e.Cancel = true;
}

if ((webBrowser1.Tag != null) && (webBrowser1.Tag.Equals(true)))
{
	e.Cancel = true;
}

This will force all pages to open in a new window, and if you set the Tag property to be true after you have loaded your initial content into the page, will prevent a link to about:blank sending the user back to a blank page!

If you happen to be reading this Moxie, kudos on your research and work on chapcrack! The story about the boat guards at the dock that you mentioned at the beginning of your talk at Defcon this year was also very amusing!

What is Chapcrack and CloudCracker?

Chapcrack is a tool you can use to take network packet captures and extract from them a string which can be submitted to CloudCracker which can finish a brute force against it in a worst case scenario of 24 hours and return to you via e-mail the cracked key.

CloudCracker does come at a cost (that being $200 per key), however if you really need to crack the key the money isn’t much to part with when you take into consideration the amount of time that will be saved if a strong key has been chosen.

Some Background on the Protocol and its Flaws

Just want to start off pointing out this research of the protocol is not my own, I am not taking credit for it, it was done by Moxie, I am just reposting it for the sake of keeping this post as informative as possible!

Let’s take a look at the protocol itself, in order to see what we’re dealing with:

At first glance, one is initially struck by the unnecessary complexity of the protocol. It almost feels like the digital equivalent of hand-waving — as if throwing in one more hash, random nonce, or unusual digest construction will somehow dazzle any would-be adversaries into submission. The literal strings “Pad to make it do more than one iteration” and “Magic server to client signing constant” are particularly amusing.

If we look carefully, however, there is really only one unknown in the entire protocol — the MD4 hash of the user’s passphrase, which is used to construct three separate DES keys. Every other element of the protocol is either sent in the clear, or can be easily derived from something sent in the clear:

Given that everything else is known, we can try ignoring everything but the core unknown, and seeing if there are any possibilities available to us:

We have an unknown password, an unknown MD4 hash of that password, a known plaintext, and a known ciphertext. Looking back at the larger scope, we can see that the MD4 hash of the user’s password serves as a password-equivalent — meaning that the MD4 hash of the user’s password is enough to authenticate as them, as well as to decrypt any of their traffic. So our objective is to recover the MD4 hash of the user’s password.

Typically, given a packet capture, this is where a network adversary would attempt to employ a dictionary attack. Using a tool such as asleap, it’s possible to rapidly attempt a series of password guesses offline. The attacker can simply calculate MD4(password_guess), split that hash up into three DES keys, encrypt the known plaintext three times, and see if the concatenated output from those DES operations matches the known ciphertext.

The problem with this approach is that it won’t give the attacker a 100% success rate, and relies on the user’s propensity for selecting a predictable password. In the case of the riseup.net PPTP VPN service, for instance, the attacker would need to attempt guesses across the full 96 key character set for all 21 characters of the generated password. That’s a total complexity of 96²¹ — slightly larger than 2¹³⁸, or what you could think of as a 138 bit key.

In a situation with an unbounded password length across a large character set, it would make more sense to brute force the output of the MD4 hash directly. But that’s still 128bits, making the total keyspace for a brute force approach on that value 2¹²⁸ — which will likely be forever computationally infeasible.

The hash we’re after, however, is used as the key material for three DES operations. DES keys are 7 bytes long, so each DES operation uses a 7 byte chunk of the MD4 hash output. This gives us an opportunity for a classic divide and conquer attack. Instead of brute forcing the MD4 hash output directly (a complexity of 2¹²⁸), we can incrementally brute force 7 bytes of it at a time.

Since there are three DES operations, and each DES operation is completely independent of the others, that gives us an additive complexity of 2⁵⁶ + 2⁵⁶ + 2⁵⁶, a total keyspace of 2^57.59

This is certainly better than 2¹³⁸ or 2¹²⁸, but still quite a large number. There’s something wrong with our calculations though. We need three DES keys, each 7 bytes long, for a total of 21 bytes:

Those keys are drawn from the output of MD4(password), though, which is only 16 bytes:

We’re missing five bytes of key material for the third DES key. Microsoft’s solution was to simply pad those last five bytes out as zero, effectively making the third DES key two bytes long:

Since the third DES key is only two bytes long, a keyspace of 2¹⁶, we can immediately see the effectiveness of divide-and-conquer approach by brute forcing the third key in a matter of seconds, giving us the last two bytes of the MD4 hash. We’re left trying to find the remaining 14 bytes of the MD4 hash, but can divide-and-conquer those in two 7 byte chunks, for a total complexity of 2⁵⁷.

Again, still a big number, but considerably better. We’re left with, essentially, this core problem:

The next interesting thing about the remaining unknowns is that both of the remaining DES operations are over the same plaintext, only with different keys. The naive approach to cracking these DES operations would look like:

…iterate over every key in the keyspace, and use each key to encrypt our known plaintext and compare it to our first known ciphertext. When we find a match, we start over and iterate through every key in the keyspace, encrypt our known plaintext, and compare it to our second known ciphertext.

The expensive part of these loops are the DES operations. But since it’s the same plaintext for both loops, we can consolidate them into a single iteration through the keyspace, with one encrypt for each key, and two compares:

This brings us down to a total complexity of 2⁵⁶!

This means that, effectively, the security of MS-CHAPv2 can be reduced to the strength of a singleDES encryption.

So Let’s Crack this Key Already!

The first thing you’re going to have to do is download the latest copy of the chapcrack source files from Here or visit the Github Page if you need a specific revision (I am using commit b2f5cf8 as of the time of writing this).

As this is a Python program, it goes without saying you’ll have to install Python! I won’t go into this here as there are plenty of tutorials around the web on setting it up in the environment of your choice.

Before you install chapcrack you may require a few prerequisites first. I installed chapcrack on a fresh install of BackTrack5, and these were the steps I had to take:

Installing Passlib

Passlib is a password hashing library for Python 2 & 3, which provides cross-platform implementations of over 30 password hashing algorithms, as well as a framework for managing existing password hashes. It’s designed to be useful for a wide range of tasks, from verifying a hash found in /etc/shadow, to providing full-strength password hashing for multi-user applications.

To install passlib, head over to the Downloads Page and grab the latest version, extract it and then open a terminal in the same directory and run the following command:

Once it’s done its thing the installation has finished and we can move on!

Installing python-m2crypto

M2Crypto is the most complete OpenSSL wrapper for Python. M2Crypto makes it relatively easy to add cryptographic support and security to your Python applications.

Again, just one small command to run and we’re done!

Now that we have the prerequisites we can install chapcrack! Change your working directory in your terminal to the directory in which you extracted the chapcrack ZIP file and then run the following command to install chapcrack:

Now that we have chapcrack installed we can give it a test whirl!

I’m not going to explain here how to capture packets over a network, as again there are lots of guides and information on this available and I’d just be reiterating them, and chances are if you’re reading this you probably know how to anyway. If you do need a push in the right direction however, have a look around for some guides on how to use Wireshark.

If you don’t have a capture file already that contains an MS-CHAPv2 handshake, throw one together or alternatively you can use the sample file (pptp.cap) in the tests directory of the chapcrack download (see below) like I will be doing to demonstrate.

To use chapcrack we just have to execute it with the parse -i command, passing through to it the path to our capture file. It should finish relatively quickly and give you back a few bits of data; the one we are interested in is the CloudCracker Submission.

Copy and paste the CloudCracker Submission string into a file and then head over to http://www.cloudcracker.com/.

Choose the MS-CHAPv2 option on the first page you arrive at, and then select the file you just created as the Chapcrack Output file to submit. From here just follow the instructions on the website, and when the crack is finished you’ll get an e-mail with the results; it’s that simple!

Apologies if I missed out any prerequisites that are not pre installed on other operating systems to BackTrack5 as this is the only system I have tested on. If you do find yourself missing any though please post a comment with your distribution and what you had to install so I can update this post!

To save anyone else from having to jump through hoops trying to figure this out I’ve put together a class called CollidableObject which will store a texture, position in world space and rotation factor and allow you to detect collisions between them by calling the IsColliding method.

In order for this class to work properly, you will also have to draw your textures using the rotation values (even if you aren’t rotating your sprite) like so:

// If the player is coliding with the enemy turn the screen red
if (this.player.IsColliding(this.enemy))
{
	GraphicsDevice.Clear(Color.Red);
}

// Draw the player to the screen
spriteBatch.Draw(this.player.Texture, 
			this.player.Position, 
			null, Color.White, 
			this.player.Rotation, 
			this.player.Origin, 
			1.0f, 
			SpriteEffects.None, 
			0.0f);

It doesn’t support the use of sprite sheets or animation, however you should be able to modify it easily to suit your needs.

Click Here to View the Code on Pastebin

To fetch the achievement data of the World of Warcraft character we are going to make use of armoryapi, the armoryapi library currently requires that the project’s target framework be 3.5 or higher so set your project up to use 3.5 or higher in the project properties.

After creating your project and setting up the target framework the next step is to add the reference to the armoryapi library. Download and extract the latest armoryapi package and you will find a DLL and an XML file inside, make note of where you have extracted these files and head back to Visual Studio. Open the “Add Reference” dialog (see http://msdn.microsoft.com/en-us/library/wkze6zky(v=vs.80).aspx) and click the tab labelled “Browse” and navigate to the armoryapi DLL that you extracted.

Note: in order for the intellisense documentation to work you must also extract the XML file to the same directory as the DLL

Code

Now that your project is setup let’s get started with some code, first thing’s first let’s create a very simple form that we can use to fetch and display the data. Create a form and add the following controls:

characterNameTextBox – TextBox
realmTextBox – TextBox
achievementList – ListBox
fetchButton – Button

You should now have something similar to this (I have added a few labels and a groupbox, but you obviously don’t have to do this to get started):

Now that we have our GUI sorted double click on fetchButton to create the click event handler for the button. Once you are in the code view we need to add an import to the ArmoryAPI namespace, to do this add the following line at the top of the file:

VB.Net

Imports ArmoryAPI

C#

using ArmoryAPI;

Once you’ve added the namespace import go back to the event handler for the button click and add the following code:

VB.Net

Dim armory As Armory = New Armory(BattleNetRegion.Europe, BattleNetLocale.en_GB)
Dim character As Character = armory.GetCharacter(characterNameTextBox.Text, realmTextBox.Text)

For Each a As UnlockedAchievement In character.Achievements
    If (DateTime.Now.AddDays(-14) < a.Unlocked) Then
        achievementList.Items.Add(String.Format("{0} ({1} points)", a.Title, a.Points))
    End If
Next

C#

Armory armory = new Armory(BattleNetRegion.Europe, BattleNetLocale.en_GB);
Character character = armory.GetCharacter(characterNameTextBox.Text, realmTextBox.Text);

foreach (UnlockedAchievement a in character.Achievements)
{
    if (DateTime.Now.AddDays(-14) < a.Unlocked)
    {
        achievementList.Items.Add(String.Format("{0} ({1} points)", a.Title, a.Points));
    }
}

If you debug the project now you will be able to fetch the achievements the character entered has unlocked within the last two weeks as can be seen below.

This code queries the European servers and returns the data in English, if you need a different configuration simply change the line that creates the Armory object, the following regions and locales are supported:

Regions

• America
• China
• Europe
• Korea
• Taiwan

Locales

• de_DE
• en_GB
• en_US
• es_ES
• es_MX
• fr_FR
• ko_KR
• ru_RU
• zh_CN
• zh_TW

Extra Steps

In order to improve upon this project, you can utiilise the caching functionality of armoryapi, to do this you’ll have to setup a database (see http://code.google.com/p/armoryapi/wiki/GettingStarted#Setting_up_a_Database) and simply pass the connection string to the Armory object and the time in minutes that the data should be cached for as shown in the example below.

armory.ConnectionString = "Data Source=(local)SQLEXPRESS;Initial Catalog=armoryapi;User ID=username;Password=password"
armory.RefreshInterval = 120

<?php
	exec("nohup /usr/local/bin/php -f /path/to/script/file.php parameterValue > /dev/null &");
?>

This will execute the PHP script stored in file.php in its own thread but the PHP script calling it will not have to wait on it finishing execution as it would be if you called the script without the nohup and > /dev/null &. This solution will only work on *nix systems as opposed to Windows, but I imagine there is probably a way to do it in Windows too. The downside to this is that you will not be able to get any return value from the script, therefore it is only of any use if you need to run a task that does not require the calling file to get the results back. You can however pass data to the script as I have done in the example above, the value “parameterValue” would be available to file.php via $argv[1], for example:

<?php

	/* -- file.php -- */
	echo 'The value '.$argv[1].' was passed to me via a CLI command.';

?>