对单片机的机器码的反编译

最新推荐文章于 2024-09-18 22:10:41 发布
最新推荐文章于 2024-09-18 22:10:41 发布
阅读量3.5k 收藏 1
点赞数
文章标签： string import null exception properties c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moliqin/article/details/1916853
版权

     应一个做硬件的同事的要求，他利用其他软件可以得到十六进制的机器码，希望做一个简单的软件，可以将机器

码反编译成汇编指令。本来网上应该有很多这方面的软件。但他说这个很特别，找不到，于是给他做了一个小软件 

现在将代码帖出来，供网友参考

source

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.StringTokenizer;

 
public class HexToAssemble {

 Properties orderProp = new Properties();
 private String instructionPath = "e:/zip/order.properties";
 String binaryCodePath = "e:/zip/input.txt";
 String outputPath = "e:/zip/result.txt";
 private String content;
 private String baseDir = "000";
 private boolean outPutFlag =true;
 private int baseInt;
 private void loadProp() {
  InputStream inStream = null;
  try {
   inStream = new FileInputStream(instructionPath);
   orderProp.load(inStream);
  } catch (Exception e) {
   e.printStackTrace();
  } finally {
   if (inStream != null) {
    try {
     inStream.close();
    } catch (IOException e) {
     e.printStackTrace();
    }
   }
  }

 }

 private void readTxt() {
  StringBuffer buf = new StringBuffer();
  File file = new File(binaryCodePath);
  try {
   BufferedReader bufread = new BufferedReader(new FileReader(file));
   String tmp = bufread.readLine();
   while (tmp != null) {
    buf.append(tmp);
    tmp = bufread.readLine();
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
  content = buf.toString();
 }

 private void dealContent() {
  try {

   PrintWriter pw = new PrintWriter(new File(outputPath));
   StringTokenizer token = new StringTokenizer(content, " ");
   int tokenNumber = token.countTokens();
   String[] orders = new String[tokenNumber];
   int index = 0;
   while (token.hasMoreElements()) {
    orders[index] = token.nextToken();
    index = index + 1;
   }
   String key = null;
   String value = null;
   String xValue = null;
   String absoluteAddress = null;
   String originalInstruction = null;
   for (int i = 0; i < orders.length; i++) {
    key = orders[i].toUpperCase();
    xValue = null;
    absoluteAddress = getAddress();
    originalInstruction = key;
    if ( Integer.parseInt(key, 16)>=128 )
    {
     xValue = key.substring(1);
     key = key.substring(0, 1) +"X";
     absoluteAddress = ""+absoluteAddress +": ";
    }
    else
     absoluteAddress = absoluteAddress +": ";
    value = orderProp.getProperty(key);
    
    if( value != null)
    {
     StringTokenizer vs = new StringTokenizer(value,";");
     String v1 = vs.nextToken();
     String v2 = vs.nextToken();
     if ( v2.equals("1"))
     {
      pw.append(absoluteAddress);
      if (outPutFlag)
       pw.append(" " +originalInstruction +"         ");
      pw.append(v1 ) .append("/r/n");
      setNextAddress(1);
     }
     else if ( v2.equals("2"))
     {
      if (  i+1 <orders.length )
      {
       i = i+1;
       originalInstruction = originalInstruction + " " + orders[i]+"   ";
       String muli = null;
       if ( xValue != null )
       {
        muli = xValue + orders[i];
        muli = changeHig(muli,v1);
       }
       else
        muli = orders[i];
       
       muli =muli+"H";
       if ( v1.indexOf("expr") !=-1)
       {
        v1 = v1.replaceAll("expr", muli);
       }
       else
        v1 = v1+" " + muli;
       pw.append(absoluteAddress);
       if (outPutFlag)
        pw.append(" " + originalInstruction+"   ");
       pw.append( v1 ) .append("/r/n");
       setNextAddress(2);
      }
      else
      {
       System.out.println("input binary code has error");
      }
     }
     else if ( v2.equals("3"))
     {
      String str7c7d = orders[i];
      if (  i+1 <orders.length )
      {
       i = i+1;
       originalInstruction = originalInstruction + " " + orders[i];
       String first = orders[i];
       if ( v1.indexOf("expr") !=-1)
       {
        v1 = v1.replaceFirst("expr", first+"H");
       }
       if (  i+1 <orders.length )
       {
        i = i+1;
        originalInstruction = originalInstruction + " " + orders[i];
        String second = orders[i];
        if ( v1.indexOf("expr") !=-1)
        {
         v1 = v1.replaceFirst("expr", second+"H");
        }
        pw.append(absoluteAddress);
        if (outPutFlag)
         pw.append(" " + originalInstruction+"   ");
        if ( str7c7d.equals("7C") || str7c7d.equals("7D"))
        {
         pw.append( v1 ).append(" ").append(""+first+second+"H").append("/r/n");
         str7c7d = "";
        }
        else
         pw.append( v1 ).append("/r/n");
        setNextAddress(3);
       }
       else
       {
        System.out.println("input binary code has error");
       }       
      }
      else
      {
       System.out.println("input binary code has error");
      }
     }
    }
    else
    {
     System.out.println(" input binary code has error ,pls check code in 0 ..255" );
     continue;
    }
   }
   pw.flush();
   pw.close();
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 private String getAddress()
 {
  String returnStr = Integer.toHexString(baseInt);
  return returnStr;
 }
 
 private void setNextAddress(int byteNumber)
 {
  baseInt = baseInt + byteNumber;
 }
 private String changeHig(String value,String operator)
 {
  //value=FFA,JZ
  String returnStr = "";
  int number =Integer.parseInt(value,16);
  int baseNumber = Integer.parseInt(baseDir, 16);
  if ( number>2047 )//80
  {
   value = "F"+value;
   number =Integer.parseInt(value,16);
  }
  
  if (
//    operator.indexOf( "JNC") ==-1  && operator.indexOf( "jnc") ==-1 &&
    operator.indexOf( "INDEX") ==-1  &&  operator.indexOf( "index") ==-1 &&
    operator.indexOf( "CALL") ==-1  &&  operator.indexOf( "call") ==-1
     )
  {
   number =number+1;
  } 
  else
  {
   number =number+2;
  }
  returnStr = Integer.toHexString( (number + baseInt) );
  if (returnStr.length()==5)
   returnStr =returnStr.substring(1);
  return returnStr;
 }
 
 
 
 public static void main(String[] args) {
 
  HexToAssemble  hta = new HexToAssemble();
//  hta.loadProp();
//  hta.readTxt();
//  hta.dealContent();  
   if ( args.length ==5)
  {
   hta.setBaseDir(args[0]);
   hta.setInstructionPath(args[1]);
   hta.setBinaryCodePath(args[2] );
   hta.setOutputPath(args[3]);
   hta.setOutPutFlag(args[4]);
   hta.loadProp();
   hta.readTxt();
   hta.dealContent();
  }
  else
  {
   System.out.println("                                                                                     ");
   System.out.println("===============================================================================");
   System.out.println("useage: java HexToAssemble baseAddress instrunction inputBinaryCode outputFile  1/0");
   System.out.println("java HexToAssemble 600 instruction.txt input.txt result.txt  1             ");
   System.out.println("===============================================================================");
  }
 }

 public String getBaseDir() {
  return baseDir;
 }

 public void setBaseDir(String baseDir) {
  this.baseDir = baseDir;
  baseInt =  Integer.parseInt(baseDir, 16);
 }

 public String getInstructionPath() {
  return instructionPath;
 }

 public void setInstructionPath(String instructionPath) {
  this.instructionPath = instructionPath;
 }

 public String getBinaryCodePath() {
  return binaryCodePath;
 }

 public void setBinaryCodePath(String binaryCodePath) {
  this.binaryCodePath = binaryCodePath;
 }

 public String getOutputPath() {
  return outputPath;
 }

 public void setOutputPath(String outputPath) {
  this.outputPath = outputPath;
 }

 public boolean isOutPutFlag() {
  return outPutFlag;
 }

 public void setOutPutFlag(String outPutFlag) {
  if (outPutFlag.equals("1"))
   this.outPutFlag = true;
  else
   this.outPutFlag = false;
 }

}

========================================================================

instruction.txt

00=SSC;1
01=ADD A,expr;2
02=ADD A,[expr];2
03=ADD A,[X+expr];2
04=ADD [expr],A;2
05=ADD [X+expr],A;2
06=ADD [expr],expr;3
07=ADD [X+expr],expr;3
08=PUSH A;1
09=ADC A,expr;2
0A=ADC A,[expr];2
0B=ADC A,[X+expr];2
0C=ADC [expr],A;2
0D=ADC [X+expr],A;2
0E=ADC [expr],expr;3
0F=ADC [X+expr],expr;3
10=PUSH X;1
11=SUB A,expr;2
12=SUB A,[expr];2
13=SUB A,[X+expr];2
14=SUB [expr],A;2
15=SUB [X+expr],A;2
16=SUB [expr],expr;3
17=SUB [X+expr],expr;3
18=POP A;1
19=SBB A,expr;2
1A=SBB A,[expr];2
1B=SBB A,[X+expr];2
1C=SBB [expr],A;2
1D=SBB [X+expr],A;2
1E=SBB [expr],expr;3
1F=SBB [X+expr],expr;3
20=POP X;1
21=AND A,expr;2
22=AND A,[expr];2
23=AND A,[X+expr];2
24=AND [expr],A;2
25=AND [X+expr],A;2
26=AND [expr],expr;3
27=AND [X+expr],expr;3
28=ROMX;1
29=OR A,expr;2
2A=OR A,[expr];2
2B=OR A,[X+expr];2
2C=OR [expr],A;2
2D=OR [X+expr],A;2
2E=OR [expr],expr;3
2F=OR [X+expr],expr;3
30=HALT;1
31=XOR A,expr;2
32=XOR A,[expr];2
33=XOR A,[X+expr];2
34=XOR [expr],A;2
35=XOR [X+expr],A;2
36=XOR [expr],expr;3
37=XOR [X+expr],expr;3
38=ADD SP,expr;2
39=CMP A,expr;2
3A=CMP A,[expr];2
3B=CMP A,[X+exr];2
3C=CMP [expr],expr;3
3D=CMP [X+expr],expr;3
3E=MVI A,[expr];2
3F=MVI [expr],A;2
40=NOP;1
41=AND REG[expr],expr;3
42=AND REG[X+expr],expr;3
43=OR REG[expr],expr;3
44=OR REG[X+expr],expr;3
45=XOR REG[expr],expr;3
46=XOR REG[X+expr],expr;3
47=TST [expr],expr;3
48=TST [X+expr],expr;3
49=TST REG[expr],expr;3
4A=TST REG[X+expr],expr;3
4B=SWAP A,X;1
4C=SWAP A,[expr];2
4D=SWAP X,[expr];2
4E=SWAP A,SP;1
4F=MOV X,SP;1
50=MOV A,expr;2
51=MOV A,[expr];2
52=MOV A,[X+expr];2
53=MOV [expr],A;2
54=MOV [X+expr],A;2
55=MOV [expr],expr;3
56=MOV [X+expr],expr;3
57=MOV X,expr;2
58=MOV X,[expr];2
59=MOV X,[X+expr];2
5A=MOV [expr],X;2
5B=MOV A,X;1
5C=MOV X,A;1
5D=MOV A,REG[expr];2
5E=MOV A,REG[X+expr];2
5F=MOV [expr],[expr];3
60=MOV REG[expr],A;2
61=MOV REG[X+expr],A;2
62=MOV REG[expr],expr;3
63=MOV REG[X+expr],expr;3
64=ASL A;1
65=ASL [expr];2
66=ASL [X+expr];2
67=ASR A;1
68=ASR [expr];2
69=ASR [X+expr];2
6A=RLC A;1
6B=RLC [expr];2
6C=RLC [X+expr];2
6D=RRC A;1
6E=RRC [expr];2
6F=RRC [X+expr];2
70=AND F,expr;2
71=OR F,expr;2
72=XOR F,expr;2
73=CPL A;1
74=INC A;1
75=INC X;1
76=INC [expr];2
77=INC [X+expr];2
78=DEC A;1
79=DEC X;1
7A=DEC [expr];2
7B=DEC [X+expr];2
7C=LCALL;3
7D=LJMP;3
7E=RETI;1
7F=RET;1
8X=JMP;2
9X=CALL;2
AX=JZ;2
BX=JNZ;2
CX=JC;2
DX=JNC;2
EX=JACC;2
FX=INDEX;2 

============================================================

input.txt

 7c 22 8E
 7C 0F EC
 50 57
 7C 03 C5
 7C 29 06
 50 4F
 7C 03 C5
 7C 29 06
 50 57
 7C 03 C5
 7C 29 06
 7C 03 D1
 21 08
 AF FA
 7C 03 CE
 53 91 7C 03 D1 21 08 AF
 FA 7C 03 CE 5C 51 91 7C
 04 A8 7C 0F EC 8F E0 7D
 20 AF 30 30 30 30 30 30
 30 30 30 30 30 30 30 30
 30 30 30 30 30 30 30 30
 30 30 30 30 30 30 30 30
 30 30 30 30 30 30 30 30
 30 30 30 30 30 30 30 30
 30 30 30 30 30 30 30 30
 30 30 30 30 30 30 30 30

pcjavanet
关注
单片机程序代码的反汇编方法及示例
UoEmacs_Lisp的博客
09-21 846
单片机程序代码的反汇编是一种重要的分析和调试工具，可以帮助开发者理解程序的执行过程和内部机制。静态反汇编适用于分析已编译的程序文件，而动态反汇编适用于实时执行程序并进行调试。反汇编是指将已经编译成机器码的程序代码，转换回人类可读的汇编代码的过程。在单片机开发中，反汇编可以帮助开发者理解和分析已编译的程序，以便进行调试、优化或逆向工程。可以添加注释，提高代码的可读性。最终的反汇编结果根据程序和使用的单片机型号而异，可以在调试工具的界面上查看。在单片机开发中，常用的反汇编方法有两种：静态反汇编和动态反汇编。
单片机程序如何反编译成C语言,如何实现单片机程序代码的反汇编
weixin_28932845的博客
05-18 2468
要正确获取程序的目标代码，首先要明确程序代码的存放地点。51单片机的程序存储器最大空间为64KB，在一个实际的应用系统中，程序存储器的分布情况可能有以下几种：(1)只使用了片内程序空间。而没有使用片外的程序空间。其硬件特征为：／EA引脚接VCC；／PSEN引脚为空脚。这种情况比较简单，全部应用程序都在单片机内部的程序存储器中，我们只要使用编程器将程序代码读出来，保存为一个目标代码文件就可以了。要注...
怎么完成单片机程序代码的反汇编
最新发布
李肖遥的专栏
09-18 337
关注、星标公众号，直达精彩内容 如何实现单片机程序代码的反汇编-要进行目标代码的变换，首先必须根据硬件画出实际的地址和数据的接线图，然后借助于工具软件进行变换。在“51汇编集成开发环境”（其下载网址为www1.skycn．com/SOFt/15074/html）中，提供了一个变换工具，从软件界面的［辅助工具］—［目标代码转换］-［bin代码还原］就可以启动这个工具。要正确获取程序的方针...
单片机(WINDOWS版)反编译工具
06-30
单片机(WINDOWS版)反编译工具 单片机(WINDOWS版)反编译工具
51单片机智能反编译软件
06-20
51内核单片机智能反编译软件,可反编ＳＴＣ,做的比较好，基本上反编译后可i汇编和原来一样ＨＥＸ机器码的
电脑机器码获取反编译工具
08-11
安装目录解压后，可获取机器码生成源代码，可用于二次开发。同时能够破解Skyline系列软件
STM32hex文件反编译成c语言,挑战一下单片机hex文件反编译
weixin_34641420的博客
05-22 7156
;==========================================================================;====Power Disassembler for MCS-51 and 6502================================;=================================================...
STM8反编译.rar_bin s19_stm8s 反编译_stm8汇编_stm8的指令_单片机反汇编
07-15
标题和描述中提到的是关于STM8S系列单片机的反编译过程，这是一个逆向工程的技术，主要用于理解已编译的二进制代码，以获得源代码级别的理解。在这个过程中，主要涉及以下几个知识点： 1. **S19与BIN格式**：S19是...
C51智能反编译器将HEX 文件反编译成C 语言
09-19
3. **反编译过程**：根据解析出的信息，反编译器试图将机器码转换为对应的C语言语句。这个过程可能涉及到对汇编指令的理解，以及对51单片机架构的深入知识。 4. **生成C源代码**：完成反编译后，软件会输出一份C语言...
一个简单程序的反编译
weixin_33757609的博客
05-31 102
看了老赵的博客从汇编入手，探究泛型的性能问题 ，突然想起以前自己写过一个关于反汇编的文章，特转过来。  源代码如下：   void main(){int a[3][3]={{1,1,1},{2,2,2},{3,3,3}};int b[3][3]={{3,3,3},{2,2,2},{1,1,1}};int c[3][3];myfunction(a,b,c);}/*3*3 矩阵相乘*/int m...
单片机反编译软件
03-20
单片机反编译软件
单片机反编译工具.7z
07-20
烧录档的反汇编软件，有几个工具，简单的程序分析可以使用
单片机开发用的C51智能反编译器
03-01
单片机开发用的C51智能反编译器,希望对您有所帮助；
MCS-51智能反编译器 v1.0中文版(51单片机反编译工具).zip
10-19
MCS-51智能反编译器 v1.0中文版(51单片机反编译工具)zip,MCS-51智能反编译器。可将51单片机的bin或hex文件反编译为汇编码。在写进了MCU的程序中，都是二进制的文件，如ROM和BIN文件，都是经过编译后生成的二进制可执行程序来，那么，怎么将这些二进制文件还原成我们可以识别的程序呢，本MCS-51智能反编译器就有这功能，可以将BIN文件还原成来汇编程序，呵呵，如果可以还原成C，这就历害了，不过，本程序还没有这个功能，当面也是没有这种程序的。
8051asm_c51反编译工具_反汇编_
09-29
用于单片机的hex反汇编成asm文件，可以很好的实现反编译功能
430单片机 反汇编 逆向 c语言代码,MSP430单片机hex反汇编、反编译、代码分析
weixin_35941169的博客
05-22 2394
单片机反汇编，二进制代码修改，单片机汇编代码分析，单片机反汇编分析，单片机逆向工程，bin或hex单片机程序还原成C代码,单片机软件加解密。单片机系列：51系列、AVR系列、PIC系列、MSP430系列、STM32、ARM7TDMI。(其它系列单片机暂时无法分析，若有需求，需要另外专门评估)。下述MSP430型号单片机程序均可以进行反汇编、反编译，都能进行HEX(TXT)二进制代码分析，都可以还原...
STC51反汇编 单片机编程者实用工具
04-21
STC51反汇编，单片机编程者实用工具，最新版
51单片机智能反编译器
10-26
超好的51单片机反编译器，可以将keil编译生成的.hex文件，反编译生成汇编语言，然后通过看汇编语言，分析其控制流程，就可以用C实现它！
单片机bin文件反编译
05-16
单片机bin文件是编译后的机器码代码，由于其不包含源代码信息，因此反编译是一件非常困难的任务。通常来说，反编译的难度与芯片架构、编译器、优化选项等因素有关。 目前，反编译单片机bin文件的方法主要有两种：静态分析和动态调试。静态分析指的是通过一些逆向工程技术，对bin文件进行逆向分析和拼凑，从而得到汇编指令和高级语言指令。这种方法需要对汇编语言和反汇编技术有一定的了解和应用能力。动态调试则是将bin文件下载到目标单片机中，通过串口等方式，利用调试器软件实时调试，获取机器码的执行过程。 不过，无论采用哪种方法，反编译单片机bin文件都需要一定的计算机知识和技术，并且需要一些专业工具的支持。而且，由于单片机bin文件的复杂性和保护机制，反编译难度非常大。因此，除非有必要分析和研究某个特定的单片机程序，否则不建议随意进行反编译操作。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值