Domain Name

A domain name is a functional way of finding the way on the internet. There are several types of Domain Names.Top Level Domains (TLDs), Country Level Domains as well as alternative Domain Names are just a number of variations. Domain names can have a major effect on the search engine rankings, and they can also be outstanding marketing tools.
Getting your business on the Internet is the most excellent way to get utmost publicity and obtain lots of work, consequently improving your earnings and profits. Hence, if you are in Australia and are looking forward to buy a domain name of your preference, then you should know the diverse choices accessible and what go well with your business.
If you wish to advertise your business or organization to Australians, then buying an Australian domain name, preferably a .com.au domain name is the perfect option. A lot of companies in Australia use a .com.au extension because it is easier for people to keep in mind. Moreover some of the businesses also prefer to buy both a .com and .com.au, so that people who unintentionally forget to type the .au will be transferred automatically to the exact website. The additional advantage of preferring an Australian domain name is that, your website will be incorporated in the Australian search results for Google, Yahoo and Bing and other search engines. Country level Domain Names are of great assistance to recognize where the organization is coming from.
Essentially, there are two methods to buy domain names in Australia. The first way is to get in touch with a registrar of domain names and look for a domain name that is, as per your necessities. And the second method is to buy a domain name in the aftermarket.
In fact, there are numerous websites that sell domain names for a set price and some others that auction off these domain names to bidders. An aftermarket even resells domain names that have concluded their listing phase or those that include soaring premium benefits connected to it.
Hence, you can come across diverse options in the domain name market which, when seized at the accurate point in time, will be able to award you several promotional and monetary profits in due course.

Leave a comment

9 Useful PHP Functions and Features

Even after using PHP for years, we stumble upon functions and features that we did not know about. Some of these can be quite useful, yet underused. With that in mind, I’ve compiled a list of nine incredibly useful PHP functions and features that you should be familiar with.
1. Functions with Arbitrary Number of Arguments
You may already know that PHP allows you to define functions with optional arguments. But there is also a method for allowing completely arbitrary number of function arguments.
First, here is an example with just optional arguments:
view plaincopy to clipboardprint?
// function with 2 optional arguments
function foo($arg1 = ”, $arg2 = ”) {
echo “arg1: $arg1n”;
echo “arg2: $arg2n”;
}
foo(‘hello’,'world’);
/* prints:
arg1: hello
arg2: world
*/
foo();
/* prints:
arg1:
arg2:
*/
Now, let’s see how we can build a function that accepts any number of arguments. This time we are going to utilize func_get_args():
view plaincopy to clipboardprint?
// yes, the argument list can be empty
function foo() {
// returns an array of all passed arguments
$args = func_get_args();
foreach ($args as $k => $v) {
echo “arg”.($k+1).”: $vn”;
}
}
foo();
/* prints nothing */
foo(‘hello’);
/* prints
arg1: hello
*/
foo(‘hello’, ‘world’, ‘again’);
/* prints
arg1: hello
arg2: world
arg3: again
*/
2. Using Glob() to Find Files
Many PHP functions have long and descriptive names. However it may be hard to tell what a function named glob() does unless you are already familiar with that term from elsewhere.
Think of it like a more capable version of the scandir() function. It can let you search for files by using patterns.
view plaincopy to clipboardprint?
// get all php files
$files = glob(‘*.php’);
print_r($files);
/* output looks like:
Array
(
[0] => phptest.php
[1] => pi.php
[2] => post_output.php
[3] => test.php
)
*/
You can fetch multiple file types like this:
view plaincopy to clipboardprint?
// get all php files AND txt files
$files = glob(‘*.{php,txt}’, GLOB_BRACE);
print_r($files);
/* output looks like:
Array
(
[0] => phptest.php
[1] => pi.php
[2] => post_output.php
[3] => test.php
[4] => log.txt
[5] => test.txt
)
*/
Note that the files can actually be returned with a path, depending on your query:
view plaincopy to clipboardprint?
$files = glob(‘../images/a*.jpg’);
print_r($files);
/* output looks like:
Array
(
[0] => ../images/apple.jpg
[1] => ../images/art.jpg
)
*/
If you want to get the full path to each file, you can just call the realpath() function on the returned values:
view plaincopy to clipboardprint?
$files = glob(‘../images/a*.jpg’);
// applies the function to each array element
$files = array_map(‘realpath’,$files);
print_r($files);
/* output looks like:
Array
(
[0] => C:wampwwwimagesapple.jpg
[1] => C:wampwwwimagesart.jpg
)
*/
3. Memory Usage Information
By observing the memory usage of your scripts, you may be able optimize your code better.
PHP has a garbage collector and a pretty complex memory manager. The amount of memory being used by your script. can go up and down during the execution of a script. To get the current memory usage, we can use the memory_get_usage() function, and to get the highest amount of memory used at any point, we can use the memory_get_peak_usage() function.
view plaincopy to clipboardprint?
echo “Initial: “.memory_get_usage().” bytes n”;
/* prints
Initial: 361400 bytes
*/
// let’s use up some memory
for ($i = 0; $i < 100000; $i++) {
$array []= md5($i);
}
// let’s remove half of the array
for ($i = 0; $i < 100000; $i++) {
unset($array[$i]);
}
echo “Final: “.memory_get_usage().” bytes n”;
/* prints
Final: 885912 bytes
*/
echo “Peak: “.memory_get_peak_usage().” bytes n”;
/* prints
Peak: 13687072 bytes
*/
4. CPU Usage Information
For this, we are going to utilize the getrusage() function. Keep in mind that this is not available on Windows platforms.
view plaincopy to clipboardprint?
print_r(getrusage());
/* prints
Array
(
[ru_oublock] => 0
[ru_inblock] => 0
[ru_msgsnd] => 2
[ru_msgrcv] => 3
[ru_maxrss] => 12692
[ru_ixrss] => 764
[ru_idrss] => 3864
[ru_minflt] => 94
[ru_majflt] => 0
[ru_nsignals] => 1
[ru_nvcsw] => 67
[ru_nivcsw] => 4
[ru_nswap] => 0
[ru_utime.tv_usec] => 0
[ru_utime.tv_sec] => 0
[ru_stime.tv_usec] => 6269
[ru_stime.tv_sec] => 0
)
*/
That may look a bit cryptic unless you already have a system administration background. Here is the explanation of each value (you don’t need to memorize these):
ru_oublock: block output operations
ru_inblock: block input operations
ru_msgsnd: messages sent
ru_msgrcv: messages received
ru_maxrss: maximum resident set size
ru_ixrss: integral shared memory size
ru_idrss: integral unshared data size
ru_minflt: page reclaims
ru_majflt: page faults
ru_nsignals: signals received
ru_nvcsw: voluntary context switches
ru_nivcsw: involuntary context switches
ru_nswap: swaps
ru_utime.tv_usec: user time used (microseconds)
ru_utime.tv_sec: user time used (seconds)
ru_stime.tv_usec: system time used (microseconds)
ru_stime.tv_sec: system time used (seconds)
To see how much CPU power the script has consumed, we need to look at the ‘user time’ and ‘system time’ values. The seconds and microseconds portions are provided separately by default. You can divide the microseconds value by 1 million, and add it to the seconds value, to get the total seconds as a decimal number.
Let’s see an example:
view plaincopy to clipboardprint?
// sleep for 3 seconds (non-busy)
sleep(3);
$data = getrusage();
echo “User time: “.
($data['ru_utime.tv_sec'] +
$data['ru_utime.tv_usec'] / 1000000);
echo “System time: “.
($data['ru_stime.tv_sec'] +
$data['ru_stime.tv_usec'] / 1000000);
/* prints
User time: 0.011552
System time: 0
*/
Even though the script took about 3 seconds to run, the CPU usage was very very low. Because during the sleep operation, the script actually does not consume CPU resources. There are many other tasks that may take real time, but may not use CPU time, like waiting for disk operations. So as you see, the CPU usage and the actual length of the runtime are not always the same.
Here is another example:
view plaincopy to clipboardprint?
// loop 10 million times (busy)
for($i=0;$i<10000000;$i++) {
}
$data = getrusage();
echo “User time: “.
($data['ru_utime.tv_sec'] +
$data['ru_utime.tv_usec'] / 1000000);
echo “System time: “.
($data['ru_stime.tv_sec'] +
$data['ru_stime.tv_usec'] / 1000000);
/* prints
User time: 1.424592
System time: 0.004204
*/
That took about 1.4 seconds of CPU time, almost all of which was user time, since there were no system calls.
System Time is the amount of time the CPU spends performing system calls for the kernel on the program’s behalf. Here is an example of that:
view plaincopy to clipboardprint?
$start = microtime(true);
// keep calling microtime for about 3 seconds
while(microtime(true) – $start < 3) {
}
$data = getrusage();
echo “User time: “.
($data['ru_utime.tv_sec'] +
$data['ru_utime.tv_usec'] / 1000000);
echo “System time: “.
($data['ru_stime.tv_sec'] +
$data['ru_stime.tv_usec'] / 1000000);
/* prints
User time: 1.088171
System time: 1.675315
*/
Now we have quite a bit of system time usage. This is because the script calls the microtime() function many times, which performs a request through the operating system to fetch the time.
Also you may notice the numbers do not quite add up to 3 seconds. This is because there were probably other processes on the server as well, and the script was not using 100% CPU for the whole duration of the 3 seconds.
5. Magic Constants
PHP provides useful magic constants for fetching the current line number (__LINE__), file path (__FILE__), directory path (__DIR__), function name (__FUNCTION__), class name (__CLASS__), method name (__METHOD__) and namespace (__NAMESPACE__).
We are not going to cover each one of these in this article, but I will show you a few use cases.
When including other scripts, it is a good idea to utilize the __FILE__ constant (or also __DIR__ , as of PHP 5.3):
view plaincopy to clipboardprint?
// this is relative to the loaded script’s path
// it may cause problems when running scripts from different directories
require_once(‘config/database.php’);
// this is always relative to this file’s path
// no matter where it was included from
require_once(dirname(__FILE__) . ‘/config/database.php’);
Using __LINE__ makes debugging easier. You can track down the line numbers:
view plaincopy to clipboardprint?
// some code
// …
my_debug(“some debug message”, __LINE__);
/* prints
Line 4: some debug message
*/
// some more code
// …
my_debug(“another debug message”, __LINE__);
/* prints
Line 11: another debug message
*/
function my_debug($msg, $line) {
echo “Line $line: $msgn”;
}
6. Generating Unique ID’s
There may be situations where you need to generate a unique string. I have seen many people use the md5() function for this, even though it’s not exactly meant for this purpose:
view plaincopy to clipboardprint?
// generate unique string
echo md5(time() . mt_rand(1,1000000));
There is actually a PHP function named uniqid() that is meant to be used for this.
view plaincopy to clipboardprint?
// generate unique string
echo uniqid();
/* prints
4bd67c947233e
*/
// generate another unique string
echo uniqid();
/* prints
4bd67c9472340
*/
You may notice that even though the strings are unique, they seem similar for the first several characters. This is because the generated string is related to the server time. This actually has a nice side effect, as every new generated id comes later in alphabetical order, so they can be sorted.
To reduce the chances of getting a duplicate, you can pass a prefix, or the second parameter to increase entropy:
view plaincopy to clipboardprint?
// with prefix
echo uniqid(‘foo_’);
/* prints
foo_4bd67d6cd8b8f
*/
// with more entropy
echo uniqid(”,true);
/* prints
4bd67d6cd8b926.12135106
*/
// both
echo uniqid(‘bar_’,true);
/* prints
bar_4bd67da367b650.43684647
*/
This function will generate shorter strings than md5(), which will also save you some space.
7. Serialization
Have you ever needed to store a complex variable in a database or a text file? You do not have to come up with a fancy solution to convert your arrays or objects into formatted strings, as PHP already has functions for this purpose.
There are two popular methods of serializing variables. Here is an example that uses the serialize() and unserialize():
view plaincopy to clipboardprint?
// a complex array
$myvar = array(
‘hello’,
42,
array(1,’two’),
‘apple’
);
// convert to a string
$string = serialize($myvar);
echo $string;
/* prints
a:4:{i:0;s:5:”hello”;i:1;i:42;i:2;a:2:{i:0;i:1;i:1;s:3:”two”;}i:3;s:5:”apple”;}
*/
// you can reproduce the original variable
$newvar = unserialize($string);
print_r($newvar);
/* prints
Array
(
[0] => hello
[1] => 42
[2] => Array
(
[0] => 1
[1] => two
)
[3] => apple
)
*/
This was the native PHP serialization method. However, since JSON has become so popular in recent years, they decided to add support for it in PHP 5.2. Now you can use the json_encode() and json_decode() functions as well:
view plaincopy to clipboardprint?
// a complex array
$myvar = array(
‘hello’,
42,
array(1,’two’),
‘apple’
);
// convert to a string
$string = json_encode($myvar);
echo $string;
/* prints
["hello",42,[1,"two"],”apple”]
*/
// you can reproduce the original variable
$newvar = json_decode($string);
print_r($newvar);
/* prints
Array
(
[0] => hello
[1] => 42
[2] => Array
(
[0] => 1
[1] => two
)
[3] => apple
)
*/
It is more compact, and best of all, compatible with javascript and many other languages. However, for complex objects, some information may be lost.
8. Compressing Strings
When talking about compression, we usually think about files, such as ZIP archives. It is possible to compress long strings in PHP, without involving any archive files.
In the following example we are going to utilize the gzcompress() and gzuncompress() functions:
view plaincopy to clipboardprint?
$string =
“Lorem ipsum dolor sit amet, consectetur
adipiscing elit. Nunc ut elit id mi ultricies
adipiscing. Nulla facilisi. Praesent pulvinar,
sapien vel feugiat vestibulum, nulla dui pretium orci,
non ultricies elit lacus quis ante. Lorem ipsum dolor
sit amet, consectetur adipiscing elit. Aliquam
pretium ullamcorper urna quis iaculis. Etiam ac massa
sed turpis tempor luctus. Curabitur sed nibh eu elit
mollis congue. Praesent ipsum diam, consectetur vitae
ornare a, aliquam a nunc. In id magna pellentesque
tellus posuere adipiscing. Sed non mi metus, at lacinia
augue. Sed magna nisi, ornare in mollis in, mollis
sed nunc. Etiam at justo in leo congue mollis.
Nullam in neque eget metus hendrerit scelerisque
eu non enim. Ut malesuada lacus eu nulla bibendum
id euismod urna sodales. “;
$compressed = gzcompress($string);
echo “Original size: “. strlen($string).”n”;
/* prints
Original size: 800
*/
echo “Compressed size: “. strlen($compressed).”n”;
/* prints
Compressed size: 418
*/
// getting it back
$original = gzuncompress($compressed);
We were able to achive almost 50% size reduction. Also the functions gzencode() and gzdecode() achive similar results, by using a different compression algorithm.
9. Register Shutdown Function
There is a function called register_shutdown_function(), which will let you execute some code right before the script finishes running.
Imagine that you want to capture some benchmark statistics at the end of your script execution, such as how long it took to run:
view plaincopy to clipboardprint?
// capture the start time
$start_time = microtime(true);
// do some stuff
// …
// display how long the script took
echo “execution took: “.
(microtime(true) – $start_time).
” seconds.”;
At first this may seem trivial. You just add the code to the very bottom of the script and it runs before it finishes. However, if you ever call the exit() function, that code will never run. Also, if there is a fatal error, or if the script is terminated by the user (by pressing the Stop button in the browser), again it may not run.
When you use register_shutdown_function(), your code will execute no matter why the script has stopped running:
view plaincopy to clipboardprint?
$start_time = microtime(true);
register_shutdown_function(‘my_shutdown’);
// do some stuff
// …
function my_shutdown() {
global $start_time;
echo “execution took: “.
(microtime(true) – $start_time).
” seconds.”;
}
Conclusion

Leave a comment

Biggest black hole

The most massive known black hole in the universe has been discovered, weighing in with the mass of 18 billion Suns. Observing the orbit of a smaller black hole around this monster has allowed astronomers to test Einstein's theory of general relativity with stronger gravitational fields than ever before.
The black hole is about six times as massive as the previous record holder and in fact weighs as much as a small galaxy. It lurks 3.5 billion light years away, and forms the heart of a quasar called OJ287. A quasar is an extremely bright object in which matter spiralling into a giant black hole emits copious amounts of radiation.
But rather than hosting just a single colossal black hole, the quasar appears to harbour two - a setup that has allowed astronomers to accurately 'weigh' the larger one.
The smaller black hole, which weighs about 100 million Suns, orbits the larger one on an oval-shaped path every 12 years. It comes close enough to punch through the disc of matter surrounding the larger black hole twice each orbit, causing a pair of outbursts that make OJ287 suddenly brighten.
General relativity predicts that the smaller hole's orbit itself should rotate, or precess, over time, so that the point at which it comes nearest its neighbour moves around in space - an effect seen in Mercury's orbit around the Sun, albeit on a smaller scale.

Bright outbursts

In the case of OJ287, the tremendous gravitational field of the larger black hole causes the smaller black hole's orbit to precess at an incredible 39° each orbit. The precession changes where and when the smaller hole crashes through the disc surrounding its larger sibling.
About a dozen of the resulting bright outbursts have been observed to date, and astronomers led by Mauri Valtonen of Tuorla Observatory in Finland have analysed them to measure the precession rate of the smaller hole's orbit. That, along with the period of the orbit, suggests the larger black hole weighs a record 18 billion Suns.
A couple of other black holes have been estimated to be as massive, but their masses are less certain, says Valtonen. That's because the estimates were based on the speed of gas clouds around the black holes, and it is not clear whether the clouds are simply passing by the black holes or actually orbiting them.
But Tod Strohmayer of NASA's Goddard Space Flight Center in Maryland, US, says he is not convinced that Valtonen's team has really measured the mass of the large black hole in OJ287 accurately.
That's because only a handful of the outbursts have been measured with high precision, making it difficult to determine if the precession scenario is responsible for the outbursts. "Obviously, if subsequent timings continue to agree with the model, then that would provide further support," he told New Scientist.

No limit

Just how big can black holes get? Craig Wheeler of the University of Texas in Austin, US, says it depends only on how long a black hole has been around and how fast it has swallowed matter in order to grow. "There is no theoretical upper limit," he says.
The new research also tested another prediction of general relativity - that the black holes should spiral towards each other as they radiate energy away in the form of gravitational waves, or ripples in space. This radiation affects the timing of the disc crossings and their accompanying outbursts.
The most recent outburst occurred on 13 September 2007, as predicted by general relativity. "If there was no orbital decay, the outburst would have been 20 days later than when it actually happened," Valtonen told New Scientist, adding that the black holes are on track to merge within 10,000 years.
Wheeler says the observations of the outbursts fit closely with the expectations from general relativity. "The fact that you can fit Einstein's theory [so well] ... is telling you that that's working," he says.
The research was presented on Wednesday at a meeting of the American Astronomical Society in Austin, Texas, US.


Leave a comment

Google SSL Web Search

 One of the emerging and most reliable as well as preferred means of online connections to have been widely accepted all over the web has been the Secure Sockets Layer (SSL). The SSL protocol essentially creates an invisible secure connection between the computer and the service employing the protocol such as various financial, banking and e-commerce websites. One of biggest entities of the Internet, Google has been known to use the SSL protocol for its various services including Gmail, Google Docs etc. Now, the search has begin the induction of SSL into its web search engine, though currently in the Beta mode only.

The all new SSL Google search page, will provide the users with an encrypted connection between their browsers and Google servers, thereby securely transmitting the search information to the users, without fear of the information being intercepted by a third party. The all new Google page has been modified a bit, so as to deliver identifiable differences between the conventional and the new SSL enables Google search pages. Furthermore, as with any SSL secured website, the new secured Google search page will being with prefix of ‘https’. User who use this new search page, will not presented with additional search options such as, Image Search and Maps, for the sole reason that, these services do not support SSL protocol. Also, as the transferring of the data between browsers and Google servers will be secured, hence there could a minute delay in search results.

Features: SSL Search

With Google search over SSL, you can have an end-to-end encrypted search solution between your computer and Google. This secured channel helps protect your search terms and your search results pages from being intercepted by a third party. This provides you with a more secure and private search experience.
To use search over SSL, visit https://encrypted.google.com New window icon each time you perform a search. Note that only Google web search is available over SSL, so other search products like Google Images and Google Maps are not currently available over SSL. When you're searching over SSL, these properties may not appear in the left panel.

What is SSL?

SSL (Secure Sockets Layer) is a protocol that helps provide secure Internet communications for services like web browsing, e-mail, instant messaging, and other data transfers. When you search over SSL, your search queries and search traffic are encrypted so they can't be read by any intermediary party such as employers and internet service providers (ISPs).

What can I expect from search over SSL?

Here's how searching over SSL is different from regular Google search:
  • SSL encrypts the communication channel between Google and a searcher's computer. When search traffic is encrypted, it can't be read by third parties trying to access the connection between a searcher's computer and Google's servers. Note that the SSL protocol does have some limitations — more details are below.
  • As another layer of privacy, SSL search turns off a browser's referrers New window icon. Web browsers typically turn off referrers when going from HTTPS to HTTP mode to provide extra privacy. By clicking on a search result that takes you to an HTTP site, you could disable any customizations that the website provides based on the referrer information.
  • At this time, search over SSL is supported only on Google web search. We will continue to work to support other products like Images and Maps. All features that are not supported have been removed from the left panel and the row of links at the top. You'll continue to see integrated results like images and maps, and clicking those results will take you out of encrypted search mode.
  • Your Google experience using SSL search might be slightly slower than you're used to because your computer needs to first establish a secure connection with Google.
Note that SSL search does not reduce the data that Google receives and logs when you search, or change the listing of these terms in your Web History New window icon.
Information for school network administrators
  • How will SSL search affect our content filtering services?

    When students search using https://encrypted.google.com, their searches will bypass any content filters that are in place on your network. If this is problematic for your school, you can block https://encrypted.google.com. When students continue to search using http://www.google.com, your content filtering will work as it always has in the past.
  • If your students try searching via the https://www.google.com homepage, they will be redirected to https://encrypted.google.com and will not be able to perform encrypted searches to bypass content filters.
  • If I block access to https://www.encrypted.google.com, will I block access to all of Google's authenticated services (like Google Apps for Education)?

    No; logins for Google Apps for Education New window icon and our other authenticated services are currently hosted at https://www.google.com. As long as you allow access to https://www.google.com, your organization should still be able to access all of our other services.

Does SSL provide complete security?

While SSL helps prevent intermediary parties, such as ISPs, from knowing the exact search that you typed, they could still know which websites you visit once you click on the search results. For example, when you search over SSL for [ flowers ], Google encrypts the query "flowers" and the results that Google returns. But when you click on a search result, including results like images and maps, you could be exiting the encrypted mode if the destination link is not on https://. If your computer is infected with malware or a keylogger, a third party might still be able to see the queries that you typed. We recommend that everyone learns how to prevent and remove malware.
Remember that only Google web search supports search over SSL, so searching Google Images, for example, will not be encrypted.
Technical discussion of SSL protocol-level limitations
While SSL is a clear privacy and security benefit, we are aware of some technical limitations to SSL at the protocol level that are not specific to Google's implementation:
  • A determined, skilled malicious party could potentially interpose himself into the network traffic and present a spoofed certificate to the user. In many cases, this will result in a certificate warning to the user. If you see a certificate warning, the protection may not hold.
  • An adversary with the ability to install root certificates on the machine could potentially interpose himself into the network traffic without any warnings appearing.
  • A highly capable source may be in a position to sign certificates with a standard, pre-installed certificate authority (CA), which again would allow intercept without any apparent warnings to the user.
  • Even if all web searching occurs over SSL, a passive traffic listener may still be able to observe DNS look-ups.

How can I confirm whether I'm on a secure connection?

Check to see that the URL you're on starts with https:// instead of http://. Most browsers provide a visual confirmation (such as an icon of a lock) in the address bar or in the status bar at the bottom of the page. On Google SSL search, you'll also see a special Google SSL logo with a lock icon. In addition to this logo, be sure to also check the https:// text in the address bar and any browser lock icons.
When you perform a search on https://encrypted.google.com New window icon, you might see a warning if a page has some non-secure components: depending on your browser settings, you might see the lock icon turn into a warning sign, a pop-up message, or some other form of alert. This issue is often referred to as a "mixed mode error."
Since this is a beta feature, there might be some rare cases in search over SSL that generate a mixed mode error. We're working to prevent such errors, and you can help if you report any errors New window icon through our Help Forum.

Leave a comment

World's Most Dangerous Nuclear Plant


Steam rises from the cooling towers of Metsamor nuclear power station in Armenia in September 2010. One of the last old operating Soviet reactors built without containment vessels, its location in a seismic zone has drawn renewed attention since Japan's earthquake-and-tsunami-triggered crisis.

Marianne Lavelle and Josie Garthwaite
Published April 11, 2011

Leave a comment

Detecting shape-shifting computer viruses

Researchers at a software company which makes antivirus and security products have developed a computer tool that can create shape-shifting viruses that elude detection by commercial virus scanners. The aim of the research, published in the current issue of the International Journal of Multimedia Intelligence and Security, is to try to stay one step ahead of the people creating viruses with malicious and criminal intent. If an antivirus company can create an undetectable virus then it is, the reasoning goes, only a matter of time before a virus writer will do the same.
Priti Desai of Symantec Corporation, in Mountain View, California, working with alleged former National Security Agency cryptanalyst Mark Stamp now at San Jose State University, have focused on so-called metamorphic viruses. These self-replicating pieces of computer code are modified when an infected computer makes a copy so that the code still carries out the same malicious function but is different enough from the parent virus to avoid detection.
Without a common “signature” of duplicated code, each generation of a metamorphic virus can elude detection by antivirus software that relies on identifying the presence of that signature. Unfortunately, computer viruses, as with their counterparts in biology, represent a continual game of catch up. Each new generation of virus created attempts to evade detection and the providers of antivirus software attempt to detect and eradicate each new generation, just as one’s immune system must constantly adapt to each new generation of the common cold virus, for instance.
In order to stay one step ahead of this game of catch-up, researchers have devised their own computer virus generator that can produce generation after generation of metamorphic viruses that are very diverse and so different from the original parent virus. In tests, this new metamorphic virus generator easily defeats conventional antivirus software. But, despite the diversity of the code across generations of viruses, the researchers have demonstrated that machine-learning tools such as Hidden Markov Models (HMMs) are nevertheless effective at detecting even metamorphic viruses.
The team assumes that by now virus writers will be fully aware of this problem and will be working on ways to defeat even powerful HMMs. As such, the team is tweaking their metamorphic generator to see if they can defeat the statistical-based detection methods of HMMs and so find ways to improve the detection prowess of HMMs to get a step ahead of even those viruses.
Research Blogging IconPriti Desai, & Mark Stamp (2011). A highly metamorphic virus generator Int. J. Multimedia Intelligence and Security, 1 (4), 402-407

Leave a comment

US government contractor developing "microwave gun"

 
 
Ah, the beloved "electronic bomb," able to disable all technology in its vicinity: variations on the concept go way back, but useful prototypes remain tantalizingly out of reach. Into the breach steps defense contractor BAE Systems, taking a fresh crack with a High-Powered Microwave (HPM) gun intended to disable small boat engines – if successful, the technology may also target ships, UAVs, and missile payloads. The secret-shrouded weapon sounds similar to Boeing's planned airborne EMP weapon, but lacking the missile delivery systems. BAE seems to be betting big on electromagnetic warfare as a future battlefield tactic, with a manager pitching the sci-fi scene to Aviation Week:
"Unlike lasers, HPM beams don't need a lot of accuracy. With a fan [of HPM energy] you can target 10-30 small boats. If you can knock out 50-75% of the engines in a swarm, you can then concentrate on the remainder with lasers or kinetic [cannons]."
To develop better defenses against such attacks, the contractor received $150,000 from the Air Force to test-fire microwaves at military computers. No word on whether said defenses involve generous use of tin foil.
Boing Boing
sourceDanger Room

Leave a comment

HECTOR insect-inspired hexapod walking robot

We've seen some rather nightmare-inducing robots inspired by insects, but, once again, the folks at Germany's Bielefeld University have managed to turn something inherently creepy into a rather lighthearted affair. HECTOR, or hexapod cognitive autonomously operating robot, was designed to help its creators understand how exactly real animals manage to move so gracefully. Physically speaking, HECTOR sports six legs, with 18 joints in total, that protrude from an exoskeleton made of carbon fiber reinforced plastic. Its legs are given a rather life-like range of motion provided by a special set of "elastic joint drives" and a series of "biologically inspired" algorithms, and its exoskeleton can carry a load weighing 30 kilograms -- the robot itself weighs a mere 12 kilograms. What's more, HECTOR's built to learn from its experiences. Okay, so a three foot robotic insect that can carry nearly three times its weight does sound kind of creepy in retrospect, but HECTOR really does have some smooth moves. You can see for yourself in the video after the break.




Leave a comment
Umanda Jayobandara. Powered by Blogger.