Flash application .swf de-compiling

Flash application .swf de-compilation

Flash is the technology developed by Adobe which were first named as Micormedia the flash work like java and .net they have created a flash plyer which execute the compiled application flash applications are developed in different tools like Flash professional and adobe flux they have different platform here we will focus on the .swf platform which is used for application development. The .swf applications are portable and light weight we use the are mostly used for online web application. there are a lot number of applications and games which are developed in flash the miniclip.com is one of the beg resource which contains the .swf appliction more ever the flash appliction development is alo easy as compared to other and gives a rich visual user interface to the users 
 So most of the flash applications are developed in adobe flash professional and gives out put for distribution as .swf. The swf files contains the Action Script and images and others resources.These .swf files are rendered in Web Browser where they execute on the client side at flash player as like the the java JVM. The flash is the big platform for such a types of applications and many of the web sites have them now days flash is an important part of web development

De-compilation of Flash .swf files

Download the JPEXS flash free de-compiler
The de-compiler is free of cost and easy to download
The installation process is straight forward
Double click on .exe and setup process will start
Its pre-requisite is java
Go to java page and download
Install it and run
Now your de-compilation starts
Click on Open
And select your .swf file and Open
Now click on export Export to Fla
And it would be saved as flash professional cs 6 .fla
Which is compressed file

Recompilation of flash .fla of .swf file

the .fla is flash supported file
Open the file in the Flash Professional
Make the changes you needed in its ide
And recompile it to the .swf file
It is an easy process

Android application .apk decompiling

Android application .apk decompiling

Android development is different from general desktop application development it use different languages and package the application as android package. The applications are developed using java and XML mostly. XML is used for designing and java for backed processing it is also the modern application development methodology where program is separated from code it have its own virtual machine for application development is developed by keeping mobile devices resources in mind. Android is a huge platform the Virtual machine used for its application execution is Dalvik VM developed in Google the binaries here for execution are the .apk file so we will focus on how it execute the below figure show the execution of the .apk on android.


Here due to the VM concept the de-compilation process is easy so we will go through de-compilation rather then dissembling.the dissembling and and de-compiling both are easy here because the dissembly code are in form of simula language which is an easy to understand but here we will focus on the de-compilation of the application so below is the process for the purpose of both de-compilation and dissembling.

De-compilation of Android .apk files

Download Apk_OneClick tool from internet using google
Extract the attached achieve to hard disk.
Open the extracted folder.
double-click 'shellext-add.cmd'
It will install the Apk_onclick tool
And will also add the context menu items by right clicking on .apk it would be shown
So here we will de-compile all the .dex files with the it
As we know that .apk is basically an archive for execution
So extract it through 7Zip or any utility

Now Right click again on the and Click on Browse code
Browse the code in jd-gui and save as source project
Place back the code in the extracted apk in its required sequence
Import that in your Eclipse sdk environment and make change as you needed
This is your jd-Gui view which would be familiar to you if you have done of java DE-compilation
Or read out the de java DE-compilation and you will learn
Now you will face som difficulties because the akp don’t give you the full flagged and android importable package so you have to make it by your self or have to make change

Recompilation of Android package to .apk

Make your project formate like of android
Make change through any other editor and save
Use the command line to compile and package the project
Than send it to your phone and check whether you have done the good job or bad
We don’t have showed here a specific way because every one choose and create an easy way in reverse engineering for there self
You can also make the package for eclipse and then compile and make changes in it there but the process would be more time consuming instead of using command line so do it in your way in which you like
We will show you the Dissembling process in future which is the best way for doing it

C# and VB code de-compilation and recompilation


As now days the c# and vb based business application are rapidly increasing due to its easiness and productivity rate developers are moving toward it.it use .net platform for development the .net have the similar architecture design like Java the code is compiled to .exe or .dll library those binary's are basically the MSIL(Microsoft Intermediate Language) or CIL (common Intermediate language) which is then compiled and executed by the .Net Just in time compiler the process is as bellow






In the above diagram we have shown the process of execution of .net based application the application is firstly compiled to to MSIL or CIL from all languages these are saved as .exe or .dll which exhibit the binary format so the code is used to be compiled by the CLR (Common Language Runtime) which will execute the .exe or the .dll on machine based instructions
The .net platform give us many great feature that create once and execute on any machine which have the platform installed here we do not have the need to change a single instruction and we just execute it.The applications are mostly developed in C# which is the newest and advanced easy language which contains all the great features of old languages or we can say that it is developed from the good features of those languages which were in past. .exe and .dll can be both de-compiled easily but disassembling is also possible easily but in first we will discuss the de-compilation process

C# and VB .exe and .dll de-compilation

Ø Go to http://www.ilspy.net/ and download ILSpy
Ø Download the binaries
Ø It would be in .zip formate extract it to some directory
Ø Double click on the ILSpy.exe
Ø The window will pop up
Ø
Ø Next step is to go to File menu Click on Open
Ø Select your required file which may be .exe or .dll and Open it
Ø You will get the following form of your code
Ø

Ø Now the next Step is go to File menu
Ø Click on Save Code

Ø The File would be saved as .csproj
Ø Which is the default project file of C#
Ø Now open it in the Visual Studio remove the errors and Redefine the references of which libraries are not saved in .csproj
Ø Make changes in it which you want

Recompilation of the c# (.csproj) project

As the .csproj is the default C# project file so open it in C# make changes in it for which you have de-compiled the project and remove the errors from it and click on Run.
The process is easy but you know that practice make a man perfect you have to do those things repeatedly and you will learn the fastest ways for doing this there are a lot of other Open Source and closed source tools but the one which we have used (ILSpy) is also good so use it and work on different types of tools and a day will came when you will get your way of doing those things faster
It is Really a funny work and you will get a lot of fun out of it.It will also teach you that how the things work in real so this is your start we have started the thing from De-compilation of Java and C# because if you directly start from the disassembling you will newer enjoy learning it because the disassembling needs more efforts than the de-compilation so practice on it you will get a lot of c# based program from web

Java .jar and .class De-compilation and recompilation


Java .jar and .class de-compilation and recompilation

if you are familiar with java it is too good but hover you must be have to know that how to write program in java.Java is an advanced language it is mostly used in network based application and for cross platform development the java application execution architecture is as follow




Java code which are saved in .java file are compiled to .class file which basically execute on the JVM for distribution the .class files are packaged in .jar archives which also execute on the JVM so now as our binaries must be .class or .jar files so we have to work on those to reverse it the .class file have the name as that of .java and when the .class file is brought to JVM it frist start to execute main() function if it exists(in libraries there are no main() function) So our starting file in java files must be that one which have main.Now we know that .class is byte code executable on JVM files so we are going here to de-compile it to the .java so we can also use the .jar to be de-compiled the same way de-compilation process is below in simple steps

De-compilation of .Jar or .Class files

Ø First of all go to to the site http://java.decompiler.free.fr and download “Java Decompiler
Ø if it does’t exists search in google “Java Decompiler” or Jd-Gui and download it
Ø It is a single stand alone Gui application just double click and open it
Ø An Application will pop up like below one





Ø This is Java Decompiler window
Ø Go to File menu and click on open
Ø Select your .jar or .class file and click on open
Ø And you will see the code as below in Java Decompiler



Ø Go to file and Click on Save all sources if you have opened a .Jar package
Ø The next step is to give name and it would be saved as named given a zip archive


Ø Save it
Ø Now you have successfully de-compiled the byte code
Ø It is now time to make changes in the code according to your needs
Ø Do it and save the .java file
Ø If your file contains too much class and codes you have to use extra tools to get to your required position
Ø Make the changes you want and save file

Recompilation of .java files

The java files compile easily with the java jdk(Java Development Kit) use it and compile your changed .java files. The process is easy but making the required change take a lot of time so you have to do it be patiently. Firstly you have to understand the code many tools can help you in the process there are a lot of free and paid tools those tool also recover the architecture and also to recover the class diagram this is the easiest type of Reverse Engineering you will find a lot of fun as we go further and further read on you can do it and you will learn a lot
Ø Keep in mind java program always start from main(String[] arg) function

Reverse Engineering Intro

Software reverse engineering is the process of recovering a software code from its binary and making changes in it.the software companies like Microsoft,Adobe etc are trying to protect there software's against the Copying or illegal distribution.They provide the online activation process.The protection of there software are there legal right but still people are trying to remove these constraint and redistribute or copy it. The process is done by reverse engineering.
This is illegal but upon they are good we know a lot of country in the world are said 3rd world countries the people of those countries are poor and have right to use those new things in the world, which exists so they use reverse engineering process and get a way to use it.
The Reverse engineering of software involves the study of software, which should be reversed there are some steps in reversing which are bellow.

I. Study of Software
II. Get information from Software
III. De-compiling the Software if possible
IV. Disassembling the Software
V. Making changes in the de-compiled/disassemble code
VI. Recompiling the changed code
VII. Executing and testing

If you are going to crack a platform based full compiled or instruction based binary the you have to knowledge of assembly language.if your binary is a VM(virtual Machine) based then it is easy you can just De-compile and you will see all the original code of the binary.like if it is Java .class or .jar then you will get the .java files We will discuss all of the type using the following sequence.

1. Java .jar and .class de-compilation and recompilation.
2. C# and VB assemblies(.exe and .dll) de-compilation and recompilation.
3. Android .apk de-compilation and recompilation.
4. Flash .swf files de-compilation and recompilation.
5. .Net based assemblies(.exe and .dll) disassembling and Assembling.
6. C++ generic files disassembling and Assembling.
7. Delphi files disassembling and Assembling.

By following the above sequence at the end you will be at the pretty sure to say your self a Software reverse engineering the first type would be an easy and going through toward the harder way here we will use a lot of open source softwares to do the above job you dont have a need to buy a Paid tool but paid are also available try them by your self

Obfuscation, why it is needed, obfuscators and recommendations on the draft to the obfuscation

Obfuscation - there is such a word.
Warning - this article is very common term "obfuscation" and its derivatives, if you read the article out loud, it may seem that you are brainwashed. None of such appliances and replace the word "obfuscation" shorter did not find myself tired of that word. So do not read this article out loud at bedtime or before dinner, as the Soviet press, or replace the word with "entanglement" (let's see what you get) or Oh. ;)
Availability of metadata up to your code (of course this is MSIL, but more readable than assembly language code) in products. Net has become a headache for developers of commercial products and technologies. Net. How to protect code from prying public, how to protect the product that is the intellectual property (if it can be easily understandable to decompile the code, then you can remove the protection from unauthorized use, and even then assemble into a working assembly!)?
Here comes to help obfuscation.
Result. 

Here is an example of the original method (before obfuscation) 
  private void CalcPayroll (SpecialList employeeGroup) {
   while (employeeGroup.HasMore ()) {
     employee = employeeGroup.GetNext (true);
     employee.UpdateSalary ();
     DistributeCheck (employee);
   } 
 } 
But the result (after):
  private void _1 (_1 _2)
  {While (_2._1 ())
   {_1 = _2._1 (True);
    _1._1 ();
    _1 (-1);
   }
 } 
Try to understand the meaning of the algorithm after the obfuscation. It will take time - it is necessary to know what kind of classes are involved, try to understand their purpose in general to be a big job.
This is the task of obfuscation - make it difficult to understand the source code, confuse and eliminate the logical relationships in the code.
What makes obfuscation:
  1. The metadata, since not all members of the assembly, he can obfuscate. For example obfuscator not replace the names of the designers type - it can be dangerous. Although in some cases this is possible. Also sometimes impossible obfuscation of virtual or abstract methods.
  2. List of members of the assembly is ready for obfuscation. Obfuscator assigns them new names, based on a specific algorithm. Some obfuscators assigned names as long as the former were but devoid of meaning, others are based on the numbering of all members and obfustsiruyut mx corresponding numbers of the assembly, and others - based on the token (token) a member of the assembly - a unique identifier of a member of the assembly in MSIL, the fourth try to minimize length of the name, and often use the same name to the members of the assembly (in dotfuscator is called overload induction) - it gives the maximum effect of obfuscation (imagine that your class all the methods and fields are named as "1").
  3. After this data is written back to the assembly, or the generation of a new build - all in the hands of the authors obfuscators, its optimization - as many of the obfuscators are able to remove unnecessary information from the assembly (debug-information, the unused methods, fields, classes). Voila - ready to build. In fact, after the assembly obfuscation is different from the original one detail - the modified section of strings (String Heap or # Strings) - one of the five sections of the metadata is the result of a character obfuscation when the obfuscator does not modify the method bodies. Can be modified by another section (User Strings or # US) - but so far not seen such obfuscators. If interested, I can somehow tell you about the structure of metadata and PE-file. Net assemblies. (Editor's Note. Yeah, it's interesting. So - wait ;))) Open in ildasm or Reflector or another navigator, assemblies and evaluate results . Some obfuscators have additional features: entanglement namespaces (change accessories of different classes defined namespace), encryption string and image resources, control of obfuscation on the basis of specific attributes, which are marked with the members of the classes in the source code, some are trying to flirt with the MSIL-code assembly methods. Science never sleeps, seeking new opportunities to help you and offer a little more than offer (or require :)) competitors.
Pros and Cons
Pros:
  1. Obfuscators make disassembly difficult to study, making IsLicensed () to x ().
  2. Some obfuscators use ILDASM bugs for protection against disassembling it (Salamander).
  3. Some obfuscators even convert the code into native code, making it useless disassembling (Salamander).
  4. Some obfuscators encrypt and pack your exe and his ilk referenced assembly into one exe-file, so that the size of the bend can be reduced 2-4 times and can not be disassembling (Thinstall).
Cons
  1. The product is disassembled.
  2. Assemble the assembly after disassembling it is possible.
  3. IL code - available to read and understand than c assembler.
  4. "Protection" obfuscators who use bugs ILDASM disassemblers are powerless over other developers.
  5. Protecting obfuscators that use encryption character of the metadata string and binary resources prevent users of the product, debug, and test their products. Other than that - it's a risk because some character data used in Reflection - to get the type (GetType ("MyType")), or download the resource (GetManifestResourceStream ("MyResource")).
  6. Obfuscators often have a lot of settings, obscure or difficult to understand the normal user. Lack of information the user may lead to obfuscate his prog will not work as it should, and sometimes lead to the Crash, but still not caught by the debugger.
  7. Price - the price range - from 40 to 1,500 dollars for the program. And the price can not say anything about the quality of obfuscation. It may well be that the 40-dollar obfuscator to protect your project is much better than the more expensive.
  8. As for his 4-plus. Protected so prog "rigidly tied" to the used. Net Framework, and the service pack that you installed, "demolish" the correctness of the protected program. And this protection is available only for Intel-processors.
  9. As for the 5th plus. Yes indeed a defense is strong and overcomes the drawbacks of the 4th plus. The product is loaded from the resource required assemblies in memory and managed exe file and passes control to it, doing only razrulivaniya problems with assemblies, types, resources (through AssemblyResolve, TypeResolve, ResourceResolve). But - not all assemblies are needed immediately, loading them requires decryption and unpacking - extra time and CPU load. Not all produce exe-files. A Thinstall will only work with the exe, dll-as the assembly does not have a CPU before DllMain, from which it was possible to produce. But - the crack of her problems as it is possible. There is a program ProcDump - it can prodampit running process and thus easily decrypted and uncompressed protected exe, referenced assembly. Thinstall will have problems with loading into memory managed C + + assembly.
  10. Some obfuscators create a closed system obfuscated assemblies, which are neobfustsirovannymi party assemblies and MS-vskie. But here, everything is far from perfect - obfuscator does not know how to use assembly resources, so it can cause your program to a standstill. Although in this case the quality of obfuscation is ideal - to nothing to undermine. Again - this is only possible for the exe-programs. If you need to protect a class library, you will need to leave neobfustsirovannymi public members of classes and public classes - hence the cracker can begin its work.
Obfuscators and their capabilities:
Remotesoft Slamander Obfuscator -
It has a fancy navigation, allowing to climb not only the metadata, but also on the structure of PE-file, utilization analysis, binary data. Rich possibilities for the analysis of metadata. No callgraph analysis methods. There is a disassembler, but disassembles the whole class at once, no less - you have to wait. Can be used as editor sortsov. Good character obfuscation, declared protection disassembler does not work - I quietly opened the method obfuscated them. Does not work with projects and with sets of assemblies. Navigator (explorer) has a plug-in architecture that allows you to connect modules from Salamander to it. Apply overload induction - ie as soon and often Applicability names for the members of the assembly. Also offering Protector - which turns your methods in the native embedded code - do not disassemble, but are dependent on the current version. Net Framework. Do not try to give :)) Declared optimization assembly has not been made (does really?). Written in native code.
Preemptive Solutions Dotfuscator - Community Edition of the obfuscator is distributed with VS. Net 2003. The poor interface (Delphi?>obfustsiruet like everything, it's hard customizable, it is difficult to understand, but as integrated into the VS addin. Do not become set, far away. Works with the bodies of the methods confusing control flow, ie just for all sorts and while. Why dotfuscator distributed with VS - does not matter to me. Works with projects through integration sostudiey. Maybe the other versions of it abruptly - Community Edition but I did not like.
Rays.Net ILObfuscator - new version 2.5 is very different from the previous 2.0. A lot of high-quality changes. First came GUI. What makes the task much work with assemblies. ILOGUI - it's navigator assemblies, disassembler, the system will work with the project obfuscation, it is possible to view and extract the resources contained in the assembly. What is different from the others? Managed code - C # and managed C + +, working with a set of assemblies, and hence the cross-obfuscation, which allows to reach the maximum level of obfuscation, a good and intuitive GUI c VS IDE-like MDI interface that comes with the ILO SDK, allowing you to create your own system of obfuscation, easy to work with the properties of the project, there is a collection of substitutions and deletions, flexible opportunities for obfuscation - say a feature on the entanglement of namespaces (you can choose from Varant) are also offered a choice of options for names obfuscated classes. There is a function to optimize assembly after obfuscation, but only for managed assemblies without embedded native code. ILO samoobfustsirovan - you can see it as obfuscation. Of the declared on the next version fichey - support solutions - ie sets of projects, the generation of maps of obfuscation and import them to the obfuscation of the projects, these features will have to fix the result of obfuscation and use it in the next obfuscation of the project and reduce the test assembly after obfuscation and most obfuscating the project. Besides promised optimization function to supplement fichey remove unused members of the assembly and insert function analysis of the project to identify the add, add bookmarks, and navigation history.
Lesser Software LSW IL-Obfuscator - Easy and fast Tulsa, which for many will come up. A little setup, everything is clear and simple. Takes as Il-files and the compiled assembly. Though not all - sometimes gives some strange error, and does not raise skopilirovana assembly. The impression that he was her first disassembles. Does not work with sets of assemblies, but supports the replacement and elimination of obfuscation. Native code. But for $ 40.
Thinstall (now also from the Lesser Software) - This thing just works only with the exe-files. Creates a self-installing exe-file with all the files on the board, closing the disassembly of the assembly. This file is not without effort, but is revealed, we should not delude ourselves. As recognized by the producers themselves - is best used together with the obfuscator.
Owl wise demeanor - not yuzal not give. Many things can - and removes unnecessary information from the metadata, encrypts the string variables, works with multimodular assemblies (rarely used thing) and integrates with VS.Net. But it is worth nemeryannom $ 1,250. Rate this masterpiece not give.
So where do you start?
With the design of the system (application or class library) that you are going to write. Yes, if you want to write the most secure code, you have to consider several factors when designing your product.
Not to be confused with the programming design. What factors should be taken into account? Obfuscator not God just can not, so you should go to meet his or her abilities. Typical obfuscation is a character (taking into account all the pros and cons mentioned above) - when the obfuscation that's all changing names of the types, fields, methods, properties, and events for senseless. Say Obfuscator renames the type to 0, and its method Run () - also at 0, and the parameters of the methods just renumbered - 0,1,2,3,4. After such obfuscation is lost logical connection between classes, disassembled code - hard to read.
If you are going to obfuscate the closed system - then you will approach a complete obfuscation when changing all the names of the members of the assembly, and in this case, the ends to find an order of magnitude more difficult than in the case where some methods, the types you are not obfuscated (this is possible when obfuscation exe-files do not use Reflection).
By the way except for the character obfuscation is more obfuscation algorithms methods - simple multiplication when I * 3 can be represented by a more complex algorithm, for example - I * ((1 + 1/2) * 2), or confused while, and for. But we will only talk about the character of obfuscation, with reference to the obfuscation. Net assemblies.
In the future, I will call obfuscation Oh, for short. Rarely has a fully enclosed, self-contained system, so a typical case would be a partial Oh.Although the ideal goal for a better Oh! will be just writing the maximum closed-loop system assemblies. Here is the first factor.
Guidelines for the preparation of the project (product) to obfuscation:
  1. To complicate disassembly you can make a substitution types (which is not always possible to implement because of the sealed type) There is a view of such a trick in store - a system type SomeType inherited a new type AnotherType, which is suitable for O! (For instance, it lies within sight of your build, you can assign it as internal) and you have it easy obfustsiruete. The output we get instead ispozovanie SomeNamespace.0 known System.SomeType. Of course you can install it AnotherType - it's a simple successor from SomeType, but it will take time, do not you? And we need to spend time attacker encroached on your code.
  2. If you plan to use some types like public but would like them maximum protection, they should put a "protective shell" inheritance. Some type of public SomeType can be turned into two classes: internal _SomeType (underground class), which bears the implementation of the class, except for public properties needed for serialization and for use in an external assembly for the code, and public SomeType, which will be inherited by _ SomeType ( front class), but carry an external load - to have public properties that are required to serialize, conversion for use in an external assembly code. This way you will have the opportunity to use tricks 1. to generate a class of similar types SomeType-but inherited from SomeType.
  3. Closely with attributes. Do not forget about using attributes in your code. Many of them closely enough to help the environment interact. Net with your classes. For example attribute TypeConverterAttribute - you tie it to your class, class converter SomeConverter. Not every obfuscator "knows" about it - and so you should keep the converter class of obfuscation or check as obfuscator working with attributes. Otherwise, communication established between the two classes by the attribute can be destroyed.
  4. If your class is going under the knife obfuscation, we should also think about the mechanism of its serialization. Let's say a class that inherits from Form serializes itself in such a way that if the obfuscator changed the name of its type SomeForm to 0, then there is a problem during initialization deserialize this class - he just can not find a resource 0.resources, as serialized in a SomeForm.resources.
  5. Use static string announcements instead of const string - it's difficult to find the initialization of the field (in the metadata of both announcements will be presented as the field).
  6. If you have a list of strings that you are represented as a list of string constants, better declare a string list / describe as a string array, and in the constants needed to store the index of the line in a string array.
  7. If you want to protect a certain algorithm of excess viewer - give it to perform more than one class, you distribute this task can be unload memory, but certainly difficult for these researchers to understand the problem that you have going on here.
  8. Use these features done as nested types, it will not affect performance, but will affect the "trudnoizuchaemost" your code.
  9. If we talk about the protection of the algorithms it is necessary to shift their execution is not one method, as part of the algorithm to transmit to the implementation of the different classes, ie, in fact, the algorithm will be the interaction of several classes.
  10. Initialize the form class without using. Resx and. Resources files - it is better to consult the index in order to avoid problems in the obfuscation of resources.
After obfuscation:
  1. Mandatory test the obfuscated assembly. Obfuscator not God, again. He's just doing his job, and you - a. So do not neglect the tests assembly after obfuscation.
  2. After obfuscation, be sure to check out the assembly tool peverify, that comes with the. Net Framework SDK - This utility checks the metadata of your assembly is correct. If your assembly is marked as CLS-compliant - this testing is mandatory. There are riders who correctly obfuscated assembly cover the special permission of PermissionSet.SkipVerification to avoid meeting the resulting assembly with its verification. Check - if there are any such resolution in your assembly after obfuscation, it is clear that allude to. True managed C + + assemblies are initially such permission, even if you did not mention about it in your code, this is also a hint :)).
  3. A little about the quality of obfuscation - do not be lazy, look how he obfuscator obfuscated. If obfuscation is written in native code - perhaps the authors doubt the quality of his obfuscation?
  4. Create a test project that will test your quick assembly, the article is not about that, but as long as obfuscators do not have the ability to test your build on functionality, only one does check the resulting assembly at least for the download.
  5. And most importantly - in case of problems, contact the authors, send the assembly, write what you need to achieve the goal - a specialist like a flux, while working with their product of his eyes "zamylen", he needs to throw up material for testing - what it is, the higher quality of obfuscation.
So what is the best protection. Net assemblies? To date, the combination of the tread (software protection meant) and obfuscator obfuscation and complete the project (cross-obfuscation) give the best protection. Certainly it is necessary to recommend obfuscate zamnut project as a system where all the types used by the project - obfuscated, it is possible. Since the burglary who is engaged or falling and breaking a well-protected programs - the units, it is still only possible is the joint use of these two types of products.

Windows 8 Activater


This is an amazing activator for windows 8 it activate 100%



Windows 8 Professional Final Activator.
the download link is this

Download

Instraction:
1.Run as administrator
2.Wait for the process and dont do nothing
3.It restarts automatically
Windows is "activated"
Features
============
Unlocked: Personalization,,Start screen,,Account Picture
Powered By,
www.ittales1.blogspot.com