CFF_Explorer资源-CSDN文库

共17个文件

xml：5个

dll：3个

pdf：3个

PExplorer

5星 · 超过95%的资源需积分: 29 153 浏览量 2009-06-10 09:46:27 上传评论收藏 2.07MB ZIP 举报

资源详情

资源评论

收起资源包目录

CFF_Explorer.zip （17个子文件）

CFF_Explorer

Signatures

IMAGE_FILE_MACHINE_AMD64.xml 2KB

PLATFORM_INDEPENDENT.xml 434B

IMAGE_FILE_MACHINE_I386.xml 736KB

IMAGE_FILE_MACHINE_IA64.xml 1KB

IMAGE_FILE_MACHINE_ARM.xml 54B

Scripts

4GBPatch.cff 2KB

ITReport.cff 4KB

Extensions

CFF Explorer

UPX Utility

UPX Utility.dll 84KB

UPX Utility-x64.dll 83KB

UPX Utility-IA64.dll 172KB

upx.exe 1.19MB

CFF Explorer.exe 2.02MB

SDK

CFF Explorer Scripting Language.pdf 341KB

Signatures Technical Details.pdf 22KB

ExSuiteExtWiz.msi 219KB

UPX_Utility.zip 158KB

How-To CFF Extension.pdf 267KB

CFF Explorer's Scripting Language

Introduction

The Lua Language: Brief Guide

CFF Explorer's Modified Lua

Bit Operators

Other Operators

0-Based Arrays (Or Tables)

C# Strings

Definitions

How It Works

Security Issues

Code Samples

PE Resources

Easy PE Editing

Advanced PE Editing

Generic Patches

PE Reports

Extension Setups

Functions Reference

General

Portable Executable

Win32

Conclusions

Introduction

The first version of this scripting language was introduced in the CFF Explorer VII. The initial

idea was a very simple one: offering a basic command line support to modify resources in a

Portable Executable, just like Resource Hacker. The command line / script support was

requested by a community of people who needed it for their software to change some Windows

resources. After bouncing a little bit the idea in my head it evolved into a bigger project:

providing a scripting language to do most PE tasks.

The first two possibilities I came up with were Python and Lua. Initially, I thought Python

would've been a little too much for a PE editor; it seemed to me that it would've been like

opening a door with a panzer. However, I might have been wrong. In fact, a lot of tools like

IDA are opening up to Python and my choice might have been a misjudgement. Anyway, the

Lua language is not very different in its syntax from Python. So, at least, it'll be easy for

Python programmers to use it.

For this is the first version of this scripting language, I have no idea if people will like it. Even if

it'll turn to be useless, I think it's an interesting feature, and, even though time consuming and

sometimes not so easy, it was fun adding it to the CFF Explorer.

The Lua Language: Brief Guide

Lua is a very easy language to learn. This paragraph is absolutely not an extensive guide about

Lua, rather a brief description of its main features. If you want to learn more about the

language, you can visit

Lua's documentation page. Keep in mind that there are a few

differences between the standard Lua and the one I implemented in the CFF Explorer, so check

out the paragraph about the differences.

I think the reader will eventually be surprised by Lua, which, despite of being a small

language, is very powerful. It takes quite a bit of time to discover all its features and

possibilities. This paragraph should give developers a basic idea of how to write simple scripts

in Lua, but for more advanced topics consult the online documentation or one of the several

books (yes there are quite a few) written about the Lua language.

First of all, this language is case sensitive. Thus, you can't call the function "msgbox", when, in

fact, it ought to be written "MsgBox".

The version of Lua implemented in the CFF Explorer supports 64bit numbers. This factor was

very important regarding the language choice. A language without 64bit number support

would've been unfit for the tasks it's supposed to accomplish.

Here's a little 64bit-numbers test script:

var = 0xFFFFFFFFFFFFFFFF - 0xFFFFFFFF00000000

if var == 0x00000000FFFFFFFF then

MsgBox("OK 1")

end

var = 0xF000000000000000

var2 = 0xF100000000000000

if var2 > var then

MsgBox("OK 2")

end

As you can see, the hex numbers syntax is exactly the same as in C-like languages. From the

script above you can also notice that Lua's variables are not declared with a fixed type, but

just like in Python can assume any possible type:

var = "string"

var = 4

var = true

This is called dynamic typing. One thing I like about Lua is that it doesn't rely on indentation

like Python: all code blocks are terminated by the word "end".

Lua supports arrays (or tables as they call them). A table can contain any type of data:

var = { "hello", 3, true }

Tables are made of the data itself and the key to access this data. In the example above no

key is specified. Thus, a default keys is assigned to all members: a number. To access one of

the members of the table above just write var[n]. In Lua tables are 1-based, although in the

CFF Explorer implementation of Lua this isn't the case. This is one of the things listed in the

next paragraph explaining the differences about standard Lua and the one implemented in the

CFF Explorer.

Keys can be either number or strings:

var = { ["param1"] = true, ["param2"] = false, ["param3"] = true, ["param4"] =

true }

To change the first item of this table I write:

var["param1"] = false

However, I don't think that keys are very important for the CFF Explorer scripting, since most

of the tasks I can think of involve byte arrays. Another little thing about tables: to get the size

of a table just put the # (size) operator before the table's name:

MsgBox(#var)

This will print the number of rows in the table var.

To comment something in Lua use this syntax:

-- This is a single-line comment

Lua also offers multi-line comments:

--[[

This is

a multi-line

comment

]]

Concetenating strings is very easy:

MsgBox("This is " .. "a string!")

You can also concatenate a string to a number in the same way:

MsgBox("The number of items is: " .. n)

Here is a list of the Lua language key words:

and break do else elseif

end false for function if

in local nil not or

repeat return then true until while

And here is a code sample that shows some common code blocks:

var = 1000

var2 = true

-- if

if var == 1000 then

-- code

end

-- if / elseif / else

if var == 1000 then

-- code

elseif var == 1001 or var == 1002

-- code

elseif var == 1004 and var2 == true

-- code

else

-- code

end

-- while

local n = 0

while n < var do

-- code

n = n + 1

end

-- repeat / until

n = 0

repeat

if var2 == false then

break

end

n = n + 1

until n < var

-- for (exp3 default)

for n = 0, var do

-- code

end

-- for (exp3 explicit)

for n = 0, var, 2 do

-- code

end

-- for (array iteration)

gen = { 10, 20, 30, 40 }

for i = 0, #gen - 1 do

MsgBox("Key: " .. i .. " Value: " .. gen[i])

end

I think the only block which needs a bit of explanation is the for loop. The syntax of the for

statement is: for exp1, exp2, exp3 do. Every value of exp1 must reach exp2 using exp3 as the

step to increment exp1. exp3 is optional, if no step is specified, the default step value is 1.

Also, in Lua it doesn't make any difference if you write:

for n = 0, #gen - 1 do

MsgBox("Key: " .. n .. " Value: " .. gen[n])

end

Or:

for n = 0, #gen - 1 do MsgBox("Key: " .. n .. " Value: " .. gen[n]) end

It's just a coding style issue.

In the above example you've seen making use of the key word "local". You can use "local" to

declare variables which are going to be valid only the scope of the current function / block.

local var = 0

-- code

end

The variable var does not exist outside this do-block. By the way, do-blocks can be used as in

the example above to have a better overview of local variables.

Let's see how to use a function:

function add1(num)

return num + 1

end

function add2(num1, num2)

return num1 + num2, num2 + 1

end

local var = 1

-- prints "1"

MsgBox(var)

local var2 = add1(var)

-- prints "1 and 2"

MsgBox(var .. " and " .. var2)

var, var2 = add2(var, var2)

-- prints "3"

MsgBox(var)

As I said before, you will be impressed by the power of Lua. As shown in the example above,

you can return more than just one value in a function's return. And not only that: Lua supports

a variable number of arguments in its functions. Here's an example:

function multibox(...)

for i = 1, #arg - 1 do

MsgBox(tostring(arg[i]))

end

multibox("ciao", "ecco")

After reading this short paragraph, I believe, every developer has entered the Lua logic and is

able to write some simple scripts.

评论收藏

内容反馈

Corner

2014-05-25

很经典的PE软件

CFF_Explorer

评论1

最新资源

CFF_Explorer

评论1

最新资源

相关推荐

CFF Explorer

CFF_Explorer.zip

CFF_Explorer反壳工具

C32Asm，CFF_Explorer，FileInfo，ImpREC，PEiD

CFF Explorer 中文版&英文版

CFF Explorer_CN.exe

穷人版进程管理器+进程pe查看工具

CFF Explorer VII

Process Explorer

Chart_Explorer

COM Explorer

Explorer Suite III (PE资源管理)绿色汉化版

PE_Explorer教程

CFFExplore 8.0

PE Explorer

PE.Explorer

Log Explorer

WS Explorer

VB Explorer

DriverStore.Explorer

python大作业 含爬虫、数据可视化、地图、报告、及源码（整和为一个文件）（2014-2020全国各地区原油加工量）.rar

仿真电路以及操作方法

【纯干货啊】华为IPD流程管理(完整版).pptx

可编程语言标准IEC61131-3中文版.pdf

OFDM完整仿真过程与教程.zip

python大作业含爬虫、数据可视化、地图、报告、及源码（整和为一个文件）（2014-2020全国各地区原油加工量）.rar