Microcontroller reverse engineer
Microcontroller reverse engineer
Everything they make, We can break! 
  HOME COMPANY PCB COPY MCU CRACK FAQ CONTACT US
Disassembler Software   
WHY US ?
World first mcu hack company
In business since 1998
Reversed tens of thousands of chips
Copied thousands of pcbs
Foreseen all pertential problems
Integrity with payments
crack ic
 
 
Microcontroller Reverse Engineer Technology

The Binary Code Decompiler

 

 

The dcc Decompiler

The dcc decompiler was developed by Cristina Cifuentes while a PhD student at the Queensland University of Technology (QUT), Australia, 1991-4, under the supervision of Professor John GoughMike Van Emmerik developed the library signature recognition algorithms while employed by QUT.  The dcc distribution is made available under the GPL license.  The readme file provides information about the distribution.  We do not provide support for this decompiler, if you email, you'll get the standard reply.  However, we participate in the Boomerang open source project, which aims at creating a retargetable decompiler based on some of the dcc and UQBT ideas, design, and/or implementations. 

 

Table of Contents

Notice
Decompilation is a technique that allows you to recover lost source code. It is also needed in some cases for computer security, interoperability and error correction. dcc, and any decompiler in general, should not be used for "cracking" other programs, as programs are protected by copyright. Cracking of programs is not only illegal but it rides on other's creative effort. See the ethics of decompilation for more information.

 

dcc

The dcc decompiler decompiles .exe files from the (i386, DOS) platform to C programs. The final C program contains assembler code for any subroutines that are not possible to be decompiled at a higher level than assembler.

 

 The analysis performed by dcc is based on traditional compiler optimization techniques and graph theory. The former is capable of eliminating registers and intermediate instructions to reconstruct high-level statements; the later is capable of determining the control structures in each subroutine.

 Please note that at present, only C source is produced; dcc cannot (as yet) produce C++ source.

 The structure of a decompiler resembles that of a compiler: a front-, middle-, and back-end which perform separate tasks. The front-end is a machine-language dependent module that reads in machine code for a particular machine and transforms it into an intermediate, machine-independent representation of the program. The middle-end (aka the Universal Decompiling Machine or UDM) is a machine and language independent module that performs the core of the decompiling analysis: data flow and control flow analysis. Finally, the back-end is high-level language dependent and generates code for the program (C in the case of dcc).

In practice, several programs are used with the decompiler to create the high-level program. These programs aid in the detection of compiler and library signatures, hence augmenting the readability of programs and eliminating compiler start-up and library routines from the decompilation analysis.

 

 

Example of Decompilation

We illustrate the decompilation of a fibonacci program (see Figure 4). Figure 1 illustrates the relevant machine code of this binary. No library or compiler start up code is included. Figure 2 presents the disassembly of the binary program. All calls to library routines were detected by dccSign (the signature matcher), and thus not included in the analysis. Figure 3 is the final output from dcc. This C program can be compared with the original C program in Figure 4.

 

         55 8B EC 83 EC 04 56 57 1E B8 94 00 50 9A 
   0E 00 3C 17 59 59 16 8D 46 FC 50 1E B8 B1 00 50 
   9A 07 00 F0 17 83 C4 08 BE 01 00 EB 3B 1E B8 B4
   00 50 9A 0E 00 3C 17 59 59 16 8D 46 FE 50 1E B8
   C3 00 50 9A 07 00 F0 17 83 C4 08 FF 76 FE 9A 7C
   00 3B 16 59 8B F8 57 FF 76 FE 1E B8 C6 00 50 9A
   0E 00 3C 17 83 C4 08 46 3B 76 FC 7E C0 33 C0 50
   9A 0A 00 49 16 59 5F 5E 8B E5 5D CB 55 8B EC 56
   8B 76 06 83 FE 02 7E 1E 8B C6 48 50 0E E8 EC FF
   59 50 8B C6 05 FE FF 50 0E E8 E0 FF 59 8B D0 58
   03 C2 EB 07 EB 05 B8 01 00 EB 00 5E 5D CB

Figure 1 - Machine Code for Fibonacci.exe

 

 


                proc_1  PROC  FAR                        
000 00053C 55                  PUSH           bp         
001 00053D 8BEC                MOV            bp, sp      
002 00053F 56                  PUSH           si          
003 000540 8B7606              MOV            si, [bp+6]  
004 000543 83FE02              CMP            si, 2       
005 000546 7E1E                JLE            L1          
006 000548 8BC6                MOV            ax, si      
007 00054A 48                  DEC            ax          
008 00054B 50                  PUSH           ax          
009 00054C 0E                  PUSH           cs          
010 00054D E8ECFF              CALL  near ptr proc_1      
011 000550 59                  POP            cx          
012 000551 50                  PUSH           ax          
013 000552 8BC6                MOV            ax, si      
014 000554 05FEFF              ADD            ax, 0FFFEh  
015 000557 50                  PUSH           ax          
016 000558 0E                  PUSH           cs          
017 000559 E8E0FF              CALL  near ptr proc_1      
018 00055C 59                  POP            cx          
019 00055D 8BD0                MOV            dx, ax      
020 00055F 58                  POP            ax          
021 000560 03C2                ADD            ax, dx      
023 00056B 5E             L2:  POP            si          
024 00056C 5D                  POP            bp          
025 00056D CB                  RETF                       
026 000566 B80100         L1:  MOV            ax, 1       
027 000569 EB00                JMP            L2          
                proc_1  ENDP                              
                                                          
                main  PROC  FAR                           
000 0004C2 55                  PUSH           bp          
001 0004C3 8BEC                MOV            bp, sp      
002 0004C5 83EC04              SUB            sp, 4       
003 0004C8 56                  PUSH           si          
004 0004C9 57                  PUSH           di          
005 0004CA 1E                  PUSH           ds          
006 0004CB B89400              MOV            ax, 94h     
007 0004CE 50                  PUSH           ax          
008 0004CF 9A0E004D01          CALL   far ptr printf      
009 0004D4 59                  POP            cx          
010 0004D5 59                  POP            cx          
011 0004D6 16                  PUSH           ss          
012 0004D7 8D46FC              LEA            ax, [bp-4]  
013 0004DA 50                  PUSH           ax          
014 0004DB 1E                  PUSH           ds          
015 0004DC B8B100              MOV            ax, 0B1h    
016 0004DF 50                  PUSH           ax          
017 0004E0 9A07000102          CALL   far ptr scanf       
018 0004E5 83C408              ADD            sp, 8       
019 0004E8 BE0100              MOV            si, 1       
021 000528 3B76FC         L3:  CMP            si, [bp-4]  
022 00052B 7EC0                JLE            L4          
023 00052D 33C0                XOR            ax, ax      
024 00052F 50                  PUSH           ax          
025 000530 9A0A005A00          CALL   far ptr exit        
026 000535 59                  POP            cx          
027 000536 5F                  POP            di          
028 000537 5E                  POP            si          
029 000538 8BE5                MOV            sp, bp      
030 00053A 5D                  POP            bp          
031 00053B CB                  RETF                       
032 0004ED 1E             L4:  PUSH           ds          
033 0004EE B8B400              MOV            ax, 0B4h    
034 0004F1 50                  PUSH           ax          
035 0004F2 9A0E004D01          CALL   far ptr printf      
036 0004F7 59                  POP            cx          
037 0004F8 59                  POP            cx          
038 0004F9 16                  PUSH           ss          
039 0004FA 8D46FE              LEA            ax, [bp-2]  
040 0004FD 50                  PUSH           ax          
041 0004FE 1E                  PUSH           ds          
042 0004FF B8C300              MOV            ax, 0C3h    
043 000502 50                  PUSH           ax          
044 000503 9A07000102          CALL   far ptr scanf       
045 000508 83C408              ADD            sp, 8       
046 00050B FF76FE              PUSH  word ptr [bp-2]      
047 00050E 9A7C004C00          CALL   far ptr proc_1      
048 000513 59                  POP            cx          
049 000514 8BF8                MOV            di, ax      
050 000516 57                  PUSH           di          
051 000517 FF76FE              PUSH  word ptr [bp-2]      
052 00051A 1E                  PUSH           ds          
053 00051B B8C600              MOV            ax, 0C6h    
054 00051E 50                  PUSH           ax          
055 00051F 9A0E004D01          CALL   far ptr printf      
056 000524 83C408              ADD            sp, 8       
057 000527 46                  INC            si          
058                            JMP            L3         ;Synthetic inst 
                main  ENDP

Figure 2 - Code produced by the Disassembler

 

 


/*                                                            
 * Input file   : fibo.exe                                    
 * File type    : EXE                                         
 */                                                           
                                                              
int proc_1 (int arg0)                                         
/* Takes 2 bytes of parameters.                               
 * High-level language prologue code.                         
 * C calling convention.                                      
 */                                                           
{                                                             
int loc1;                                                     
int loc2; /* ax */                                            
                                                              
    loc1 = arg0;                                              
    if (loc1 > 2) {                                           
        loc2 = (proc_1 ((loc1 - 1)) + proc_1 ((loc1 + 0xFFFE)));  
    }                                                         
    else {                                                    
        loc2 = 1;                                             
    }                                                         
    return (loc2);                                            
}                                                             
                                                              
                                                              
void main ()                                                  
/* Takes no parameters.                                       
 * High-level language prologue code.                         
 */                                                           
{                                                             
int loc1;                                                     
int loc2;                                                    
int loc3;                                                     
int loc4;                                                     
                                                              
    printf ("Input number of iterations: ");                  
    scanf ("%d", &loc1);                                      
    loc3 = 1;                                                 
    while ((loc3 <= loc1)) {                                  
        printf ("Input number: ");                            
        scanf ("%d", &loc2);                                  
        loc4 = proc_1 (loc2);                                 
        printf ("fibonacci(%d) = %u\n", loc2, loc4);          
        loc3 = (loc3 + 1);                                    
    } /* end of while */                                      
    exit (0);                                                 
}

Figure 3 - Code produced by dcc in C

 

 


#include <stdio.h>                                            
                                                              
int main()                                                    
{ int i, numtimes, number;                                    
  unsigned value, fib();                                      

                                                              
   printf("Input number of iterations: ");                    
   scanf ("%d", &numtimes);                                   
   for (i = 1; i <= numtimes; i++)                            
   {                                                          
      printf ("Input number: ");                              
      scanf ("%d", &number);                                  
      value = fib(number);                                    
      printf("fibonacci(%d) = %u\n", number, value);          
   }                                                          
   exit(0);                                                   
}                                                             
                                                              
unsigned fib(x)                 /* compute fibonacci number recursively */
int x;                                                        
{                                                             
   if (x > 2)                                                 
      return (fib(x - 1) + fib(x - 2));                       
   else                                                       
      return (1);                                             
}

Figure 4 - Initial C Program

 

 

 

PhD Thesis

C Cifuentes. Reverse Compilation Techniques, Queensland University of Technology, Department of Computer Science, PhD thesis. July 1994. (474 Kb compressed postscript file). Also available in compressed dvi format (365 Kb).

 

ABSTRACT

Techniques for writing reverse compilers or decompilers are presented in this thesis. These techniques are based on compiler and optimization theory, and are applied to decompilation in a unique way; these techniques have never before been published.

A decompiler is composed of several phases which are grouped into modules dependent on language or machine features. The front-end is a machine dependent module that parses the binary program, analyzes the semantics of the instructions in the program, and generates an intermediate low-level representation of the program, as well as a control flow graph of each subroutine. The universal decompiling machine is a language and machine independent module that analyzes the low-level intermediate code and transforms it into a high-level representation available in any high-level language, and analyzes the structure of the control flow graph(s) and transform them into graphs that make use of high-level control structures. Finally, the back-end is a target language dependent module that generates code for the target language.

Decompilation is a process that involves the use of tools to load the binary program into memory, parse or disassemble such a program, and decompile or analyze the program to generate a high-level language program. This process benefits from compiler and library signatures to recognize particular compilers and library subroutines. Whenever a compiler signature is recognized in the binary program, all compiler start-up and library subroutines are not decompiled; in the former case, the routines are eliminated from the final target program and the entry point to the main program is used for the decompiler analysis, in the latter case the subroutines are replaced by their library name.

The presented techniques were implemented in a prototype decompiler for the Intel i80286 architecture running under the DOS operating system, dcc, which produces target C programs for source .exe or .com files. Sample decompiled programs, comparisons against the initial high-level language program, and an analysis of results is presented in Chapter 9.

Chapter 1 gives an introduction to decompilation from a compiler point of view, Chapter 2 gives an overview of the history of decompilation since its appearance in the early 1960s, Chapter 3 presents the relations between the static binary code of the source binary program and the actions performed at run-time to implement the program, Chapter 4 describes the phases of the front-end module, Chapter 5 defines data optimization techniques to analyze the intermediate code and transform it into a higher-representation, Chapter 6 defines control structure transformation techniques to analyze the structure of the control flow graph and transform it into a graph of high-level control structures, Chapter 7 describes the back-end module, Chapter 8 presents the decompilation tool programs, Chapter 9 gives an overview of the implementation of dcc and the results obtained, and Chapter 10 gives the conclusions and future work of this research.

The techniques presented in this thesis expand on earlier work described in the literature. Previous work in decompilation did not document on the interprocedural register analysis required to determine register arguments and register return values, the analysis required to eliminate stack-related instructions (i.e. push and pop), or the structuring of a generic set of control structures. Innovative work done for this research is described in Chapters 5, 6, and 8. Chapter 5, Sections 5.2 and 5.4 illustrate and describe nine different types of optimizations that transform the low-level intermediate code into a high-level representation. These optimizations take into account condition codes, subroutine calls (i.e. interprocedural analysis) and register spilling, eliminating all low-level features of the intermediate instructions (such as condition codes and registers) and introducing the high-level concept of expressions into the intermediate representation. Chapter 6, Sections 6.2 and 6.6 illustrate and describe algorithms to structure different types of loops and conditional, including multi-way branch conditionals (e.g. case statements). Previous work in this area has concentrated in the structuring of loops, few papers attempt to structure 2-way conditional branches, no work on multi-way conditional branches is described in the literature. This thesis presents a complete method for structuring all types of structures based on a predetermined, generic set of high-level control structures. A criterion for determining the generic set of control structures is given in Chapter 6, Section 6.4. Chapter 8 describes all tools used to decompile programs, the most important tool is the signature generator (Section 8.2) which is used to determine compiler and library signatures in architectures that have an operating system that do not share libraries, such as the DOS operating system.

 

Future Work - A Retargetable Decompiler

A retargetable decompiler engine can be built based on ideas and code from the UQBT project, by reusing the frontend of that framework and writing a new backend that supports the RTL and HRTL intermediate representation of the UQBT system.  Please refer to the open source project Boomerang.

 

 

dcc Distribution

The dcc source code distribution is made available under the GNU GPL General Public License.

 

The dcc distribution is available in gzip tar format for Unix users, dcc.tar.gz and dcc_oo.tar.gz, and in its individual .zip files for PC users, dcc files pages.  Read the readme file for a description of what is included in the distribution and installation instructions. If you do not have the tar and/or pkunzip programs, contact your system's administrator.

There is a now a second version of the decompiler; mainly to distinguish it from the first, we'll call it the "OO" version (it has the beginnings of Object Orientation, but there is still much to be done). This version has a bug fixed which caused the output to be wrong some of the time (randomly; successive runs would result in different output). It is also converted to C++, (the source for dcc; dcc does not produce C++ source), so those users wishing to use a C compiler without C++ facilities will have to stick to the original version. The file dccsrcoo.zip has the source for the later version, and dcc_oo.tar.gz has the whole distribution, with dccsrcoo.zip instead of dccsrc.zip and dcc32.zip instead of dcc.zip. This version has a better chance of working on PC compilers such as Microsoft Visual C++ and Borland C++. There is no longer any use of the curses library; it was found to be too much of a distribution hassle.

 The OO version of dcc is the most recent, and has bug fixes that the original does not. For most purposes, the OO version is the one to start working with.

Support
Please note that the authors are not currently working on this project and therefore cannot support any changes required on dcc. Source code is provided "as is". Read the documentation first.

Likewise, please don't email the authors with requests for modifications to dcc, or specific questions about its inner workings. If you do, you will just get a reply with this formletter.

Note
Dcc has a fundamental implementation flaw that limits it to about 30KB of input binary program, i.e. it currently handles toy programs only!  The problem is that pointers are kept in many places; many of these pointers point to elements of arrays. The arrays are all of variable size; the realloc system call can and will change the virtual addresses of these arrays, thus invalidating the pointers. Because of this, results are unpredictable as soon as one array is resized. (However, a segmentation fault is likely when this happens). The arrays are sized such that they don't get reallocated for input binaries less than about 30KB.

Before any serious work can be done with dcc, this implementation flaw has to be corrected. As noted above, the authors do not have the time to correct this error, or to offer any suggestions as to how to do this.

 

  • Mikatech Freescale/Motorola MCU reverse engineer list:
  • HC908 Series MCU Reverse Engineer: HC908AB32 HC908AP8 HC908AP16 HC908AP32 HC908AP64 HC908AZ60 HC908JK1 HC908JK3 HC908JK8 HC908JK32 HC908JW16 HC908JW32 HC908LK24 HC908MR8 HC908GR8 HC908QT1 HC908QT2 HC908QT4 HC908QY1 HC908QY2 HC908QY4 HC908RF2 HC908RK2 ...

    MC908 Series MCU Reverse Engineer: MC908AB32 MC908AP8 MC908AP16 MC908AP32 MC908AP48 MC908AP64 MC908AS32 MC908AS60 MC908AZ32 MC908AZ60 MC908BD48 MC908EY8 MC908EY16 MC908GR16 MC908GR32 MC908GR48 MC908GR60 MC908GZ16 MC908GZ32 MC908GZ48 MC908GZ60 MC908GP8 MC908GP16 MC908GP32 MC908GR4 MC908GR8 MC908GR16 MC908GR32 MC908GR48 MC908GR60 MC908GT8 MC908GT16 MC908GZ8 MC908GZ16 MC908GZ32 MC908GZ48 MC908JL3 MC908JL8 MC908JL16 MC908JB8 MC908JB12 MC908JB16 MC908JK1 MC908JK3 MC908JL3 MC908JL8 MC908JL16 MC908JW16 MC908KX2 MC908KX8 MC908KK3 MC908KL3 MC908LB8 MC908LD64 MC908LJ12 MC908LJ24 MC908LK24 MC908LB8 MC908LJ8 MC908LJ12 MC908LJ24 MC908LK24 MC908LV8 MC908MR8 MC908MR16 MC908MR32 MC908QB4 MC908QB8 MC908QC4 MC908QC8 MC908QC16 MC908QF4 MC908QL2 MC908QL3 MC908QL4 MC908QL8 MC908QL16 MC908QT1 MC908QT2 MC908QT4 MC908QY1 MC908QY2 MC908QY4 MC908QY8 MC908RF2 MC908SR12 ...

    MC68HC05 Series MCU Reverse Engineer: MC68HC05B6 MC68HC05B8 MC68HC05B16 MC68HC05B32 MC68HC05BD3 MC68HC05BD5 MC68HC05BD7 MC68HC05BD24 MC68HC05BD32 MC68HC05C0 MC68HC05C2 MC68HC05C4 MC68HC05C8 MC68HC05C9 MC68HC05C12 MC68HC05CC MC68HC05CJ4 MC68HC05CL1 MC68HC05CL4 MC68HC05D9 MC68HC05D32 MC68HC05E0 MC68HC05E5 MC68HC05E6 MC68HC05F4 MC68HC05F8 MC68HC05F12 MC68HC05F24 MC68HC05G3 MC68HC05G6 MC68HC05H12FN MC68HC05J1 MC68HC05J3 MC68HC05J5 MC68HC05JB3 MC68HC05JB4 MC68HC05JJ6 MC68HC05JP6 MC68HC05L0 MC68HC05L1 MC68HC05L5 MC68HC05L9 MC68HC05L13 MC68HC05L14 MC68HC05L16 MC68HC05L21 MC68HC05L24 MC68HC05L25 MC68HC05L27 MC68HC05L28 MC68HC05LJ5P MC68HC05LM1FT MC68HC05LM2FT MC68HC05P1 MC68HC05P3 MC68HC05P4 MC68HC05P6 MC68HC05P8 MC68HC05P9 MC68HC05P18 MC68HC05PD6 MC68HC05PGPV MC68HC05PV8 MC68HC05SR3 MC68HC05K0 MC68HC05K1 MC68HC05K3 MC68HC05RC4 MC68HC05R9 MC68HC05R18 MC68HC05SU3 MC68HC05T1 MC68HC05TBFN MC68HC05V12FN MC68HC05X16FU MC68HC05X32FU ...

    MC68HC705 Series MCU Reverse Engineer: MC68HC705B16 MC68HC705C4 MC68HC705C8 MC68HC705C9 MC68HC705CCVFB MC68HC705CJ4 MC68HC705CL4 MC68HC705CT4 MC68HC705J1 MC68HC705J2 MC68HC705J5 MC68HC705JB2 MC68HC705JB4 MC68HC705JJ7 MC68HC705JP7 MC68HC705K1 MC68HC705KJ1CDW MC68HC705L5 MC68HC705L13 MC68HC705L16 MC68HC705L26 MC68HC705L32 MC68HC705MC4 MC68HC705P6 MC68HC705P9 MC68HC705PL4 MC68HC705SR3 MC68HC705SB7 MC68HC705SJ7 MC68HC705SP7 MC68HC705SR3 MC68HC705T10 MC68HC705T16 68HC705X32 MC68HC705Y4CFU MC68HC705E1 MC68HC705E5 MC68HC705E6 MC68HC705G1 MC68HC705G4 MC68HC705G6 ...

    MC68HC11 Series MCU Reverse Engineer: MC68HC11A0 MC68HC11A1 MC68HC11A8 MC68HC11C0 MC68HC11L0 MC68HC11L1 MC68HC11L2 MC68HC11M2 MC68HC11D0 MC68HC11D3 MC68HC11E0 MC68HC11E1 MC68HC11E8 MC68HC11E9 MC68HC11E18 MC68HC11E20 MC68HC11EA9 MC68HC11ED0 MC68HC11EVBU2 MC68HC11F1 MC68HC11FC0 MC68HC11FL0 MC68HC11G5FN1 MC68HC11GA2VFUW MC68HC11K0 MC68HC11K1 MC68HC11K4 MC68HC11KA0 MC68HC11KA1 MC68HC11KA2 MC68HC11KA4 MC68HC11KG4 MC68HC11KS0 MC68HC11KS1 MC68HC11KS2 MC68HC11KS4 MC68HC11P1 MC68HC11PB8 MC68HC11PH8 MC68HC11PL2 MC68HC11PS6FG MC68HC11SA2CFGE ...

    MC68HC711 Series MCU Reverse Engineer: MC68HC711D3 MC68HC711E9 MC68HC711E20 MCMC68HC711M2 MCMC68HC711MA8 MC68HC711K4 MC68HC711KA2 MC68HC711KS2 MC68HC711KS8 MCMC68HC711L6 MCMC68HC711P2 MCMC68HC711SA2FG MCMC68HC711FA2 ...

    MC68HC08 Series MCU Reverse Engineer: MC68HC08AB16A MC68HC08AB32 MC68HC08AS32 68HC08AS32A MC68HC08AZ16 MC68HC08AZ24 MC68HC08AZ32 MC68HC08AZ48 MC68HC08AZ60 MC68HC08BD24 MC68HC08GP8 MC68HC08GP16 MC68HC08GP32 MC68HC08JB1 MC68HC08JB8 MC68HC08JB16 MC68HC08JT8 MC68HC08JK3 MC68HC08JK8 MC68HC08JL3 MC68HC08JL8 MC68HC08JL12 MC68HC08KH12 MC68HC08KX8 MC68HC08LD MC68HC08LT8 MC68HC08LK ...

    MC68HC908 Series MCU Reverse Engineer: MC68HC908AP64 MC68HC908AP32 MC68HC908AP16 MC68HC908AP8 MC68HC908AS32A MC68HC908AZ60A MC68HC908AS60A MC68HC908AZ60E MC68HC908AS60 MC68HC908BD48 MC68HC908EY16A MC68HC908EY8A MC68HC908GR4 MC68HC908GR8 MC68HC908GR16 MC68HC908GT8 MC68HC908GT16 MC68HC908GZ8 MC68HC908GZ16 MC68HC908GZ48 MC68HC908GZ60 MC68HC908JB8 MC68HC908JB16 MC68HC908JG16 MC68HC908JK1 MC68HC908JK3 MC68HC908JK8 MC68HC908JL3 MC68HC908JL8 MC68HC908KK3 MC68HC908KL3 MC68HC908KL8 MC68HC908KX2 MC68HC908KX8 MC68HC908LD60 MC68HC908LD64 MC68HC908LJ8 MC68HC908LJ12 MC68HC908LK24 MC68HC908LV8 MC68HC908MR8 MC68HC908MR16 MC68HC908MR32 MC68HC08QA12 MC68HC08QP32 MC68HC08QT4 MC68HC08QY4 MC68HC908QY2 MC68HC908QY4 MC68HC908SR12 MC68HC08SR12 MC68HC908SR12 ...

    MC9S08 Series MCU Reverse Engineer: MC9S08AC8 MC9S08AC16 MC9S08AC32 MC9S08AC48 MC9S08AC60 MC9S08AC96 MC9S08AC128 MC9S08AW16 MC9S08AW32 MC9S08AW48 MC9S08AW60 MC9S08DN16 MC9S08DN32 MC9S08DN48 MC9S08DN60 MC9S08DV16 MC9S08DV32 MC9S08DV48 MC9S08DV60 MC9S08DV96 MC9S08DV128 MC9S08DZ16 MC9S08DZ32 MC9S08DZ48 MC9S08DZ60 MC9S08DZ96 MC9S08DZ128 MC9S08EL16 MC9S08EL32 MC9S08FL8 MC9S08FL16 MC9S08GB16 MC9S08GB32 MC9S08GB60 MC9S08GT8 MC9S08GT16 MC9S08GT32 MC9S08GT60 MC9S08JE128 MC9S08JE64 MC9S08JM8 MC9S08JM16 MC9S08JM32 MC9S08JM60 MC9S08JS8 MC9S08JS16 MC9S08LG16 MC9S08LG32 MC9S08LL8 MC9S08LL16 MC9S08LL36 MC9S08LL64 MC9S08LC36 MC9S08LC60 MC9S08LH36 MC9S08LH64 MC9S08MP12 MC9S08MP16 MC9S08MM32 MC9S08MM64 MC9S08MM128 MC9S08MT8 MC9S08MT16 MC9S08QA2 MC9S08QA4 MC9S08QB4 MC9S08QB8 MC9S08QD2 MC9S08QD4 MC9S08QE4 MC9S08QE8 MC9S08QE16 MC9S08QE32 MC9S08QE64 MC9S08QE96 MC9S08QE128 MC9S08QG4 MC9S08QG8 MC9S08QG44 MC9S08QG84 MC9S08RC8 MC9S08RC16 MC9S08RC32 MC9S08RC60 MC9S08RD8 MC9S08RD16 MC9S08RD32 MC9S08RD60 MC9S08RE8 MC9S08RE16 MC9S08RE32 MC9S08RE60 MC9S08RG32 MC9S08RG60 MC9S08RX32 MC9S08SE4 MC9S08SE8 MC9S08SF4 MC9S08SH4 MC9S08SH8 MC9S08SH16 MC9S08SH32 MC9S08SL8 MC9S08SL16 MC9S08SV8 MC9S08SV16 ...

    MC9RS08 Series MCU Reverse Engineer: MC9RS08KA1 MC9RS08KA2 MC9RS08KA4 MC9RS08KA8 MC9RS08KB2 MC9RS08KB4 MC9RS08KB8 MC9RS08KB12 MC9RS08LA8 MC9RS08LE4 MC9RS08SA4 MC9RS08SA12 ...

    68HC16 Series MCU Reverse Engineer: 68HC16R1 68HC16Y1 68HC16Y3 68HC16Z1 68HC16Z3 ...

    MC68HC912 Series MCU Reverse Engineer: MC68HC912B32CFU8 MC68HC912B32MFU8 MC68HC912D60CPV8 ...

    MC9S12 MC9S12X Series MCU Reverse Engineer: MC9S12A32 MC9S12A64 MC9S12A128 MC9S12A256 MC9S12A512 MC9S12B32 MC9S12B64 MC9S12B96 MC9S12B128 MC9S12B256 MC9S12C32 MC9S12C64 MC9S12C96 MC9S12C128 MC9S12D32 MC9S12D64 MC9S12D96 MC9S12DB64 MC9S12DB128 MC9S12DG128 MC9S12DG256 MC9S12DJ64 MC9S12DJ128 MC9S12DJ256 MC9S12DP512 MC9S12DT128 MC9S12DT256 MC9S12DT512 MC9S12DE32 MC9S12DE64 MC9S12DE128 MC9S12GC16 MC9S12GC32 MC9S12GC64 MC9S12GC96 MC9S12GC128 MC9S12H128 MC9S12H256 MC9S12HZ256 MC9S12HZ128 MC9S12HZ64 MC9S12KG128 MC9S12KG256 MC9S12KT256 MC9S12KC128 MC9S12KT256 MC9S12NE64 MC9S12P32 MC9S12P64 MC9S12P96 MC9S12P128 MC9S12Q64 MC9S12Q96 MC9S12Q128 MC9S12UF32 MC9S12XA256 MC9S12XA512 MC9S12XB128 MC9S12XD64 MC9S12XD128 MC9S12XD256 MC9S12XD256 MC9S12XD384 MC9S12XDG128 MC9S12XDG256 MC9S12XDP512 MC9S12XDT256 MC9S12XDT512 MC9S12XEG128 MC9S12XEP100 MC9S12XEP768 MC9S12XEQ384 MC9S12XEQ512 MC9S12XET256 MC9S12XF512 MC9S12XHZ256 MC9S12XHZ512 MC9S12XS64 MC9S12XS128 MC9S12XS25 ...

    56800/E DSP Series MCU Reverse Engineer: :DSP56F801X DSP56F802X DSP56F803X DSP56852 DSP56853 DSP56854 DSP56855 DSP56857 DSP56858 DSP56F801 DSP56F801FA60 DSP56F802 DSP56F802TA60 DSP56F803 DSP56F805 DSP56F807 DSP56F826 DSP56F827 DSP56F812X DSP56F8135 DSP56F814X DSP56F815X DSP56F816X DSP56F824X DSP56F825X DSP56F832X DSP56F8335 DSP56F834X DSP56F835X DSP56F836X ...

    MC56F80xx Series MCU Reverse Engineer: MC56F801X MC56F802X MC56F803X MC56F800X MC56F8023M MC56F8023V MC56F8025M MC56F8025V MC56F8027M MC56F8027V MC56F8033M MC56F8033V MC56F8035M MC56F8035V MC56F8036M MC56F8036V MC56F8037M MC56F8037V ...

     

    MC912 Series MCU Reverse Engineer: MC912DG128 MC912DT128 MC912D60 MC912B32 ...

    MC68HC811E2 Series MCU Reverse Engineer: MC68HC812A4CPV8 ...

    MC68HRC908 Series MCU Reverse Engineer: MC68HRC908JK1 MC68HRC908JK3 MC68HRC908JL3 ...

    MC68HSC705 Series MCU Reverse Engineer: MC68HSC705C4 MC68HSC705C8 MC68HSC705J1 MC68S711E9 ...

    PC68HC908XX Series MCU Reverse Engineer: PC68HC908GP32 ...

    PC9S12 Series MCU Reverse Engineer: PC9S12UF32 PC9S12XF128 PC9S12XF256 PC9S12XF384 PC9S12XF512 PC9S12XHZ256 PC9S12XHZ384 PC9S12XHZ512 ...

    S9S08 Series MCU Reverse Engineer:
    S9S08AW16 S9S08AW32 S9S08AW48 S9S08AW60 S9S08DN16 S9S08DN32 S9S08DN48 S9S08DN60 S9S08DV128 S9S08DV16 S9S08DV32 S9S08DV48 S9S08D60 S9S08DV96 S9S08DZ128 S9S08DZ16 S9S08DZ32 S9S08DZ48 S9S08DZ60 S9S08DZ96 S9S08EL16 S9S08EL32 S9S08LG16 S9S08LG32 S9S08MP16 S9S08QD2 S9S08QD4 S9S08SG16 S9S08SG4 S9S08SG8 S9S08SG32 S9S08SL16 S9S08SL8 ...

 
 
     
 
PCB Copying Service
PCB Projects Overview
PCB Clone
PCB Reverse Engineering
PCB Prototype
PCB Assembly Production
 
 
Mcu Hacking Service
Atmel Microcontroller Hack
Actel Mcu Attack
Altera Microcontroller Crack
Cygnal Mcu Unlock
Cypress IC Reverse Engineer
Elan Mcu Code Extract
Fujitsu Microprocessor Decryption
Freescale IC Code Extraction
Gould integrated circuit Hack
Hitachi Mcu Code Extract
Holtek Chip Reverse Engineer
Infineon Microcontroller Dump
Intel Mcu Read Code Protection
ICT Microcontroller Duplication
Lattice Microcontroller Clone
Microchip Source Code Recovery
Motorola Microcontroller Crack
Maxim Mcu Attack
MDT Controller Hack
Magawin Microcontroller Unlock
NEC Mcu Reverse Engineer
NTK Microcontroller Code Extract
Nuvoton Chip Decryption
NXP Semiconductor Code Extraction
Philips integrated circuit Crack
Renesas Microcontroller Dump
ST Processor Reverse Engineer
Silicon Labs Mcu Read Protection
Samsung Mcu Duplication
SST Mcu Clone
Sinowealth Source Code Recovery
SyncMOS Mcu Unlock
Sonix Mcu Read Source Code
STC Microprocessor Code Extract
Tenx Microcontroller Decryption
Texas Instuments MCU Hack
Winbond MCU Code Extraction
Xilinx integrated circuit Crack
Zilog MCU Reverse Engineer
 
     
 
 
More MCU brands we can reverse engineer below, please contact us if yours not listed here:
AMD Feeling LG / Hyundai Myson STK
ChipON Hynix Mitsubishi National Semi Temic
Coreriver ICSI Mosel Vitelic Portek Toshiba
Dallas ISSI MXIC SSSC Gal / Pal / Palce
Copyright © 2013 Mikatech. All rights reserved. Full dedicated reverse engineering company