Rise的自留地

记录生活中的点滴，分享编程技术和游戏开发经验。

0%

发表于： 分类于： 浏览：
Lua脚本语法说明（增加lua5.1部份特性）

　　Lua 的语法比较简单，学习起来也比较省力，但功能却并不弱。
　　所以，我只简单的归纳一下Lua的一些语法规则，使用起来方便好查就可以了。估计看完了，就懂得怎么写Lua程序了。

　　在Lua中，一切都是变量，除了关键字。

I.  首先是注释
　　写一个程序，总是少不了注释的。
　　在Lua中，你可以使用单行注释和多行注释。
　　单行注释中，连续两个减号"--"表示注释的开始，一直延续到行末为止。相当于C++语言中的"//"。
　　多行注释中，由"--[["表示注释开始，并且一直延续到"]]"为止。这种注释相当于C语言中的"/*...*/"。在注释当中，"[["和"]]"是可以嵌套的（在lua5.1中，中括号中间是可以加若干个"="号的，如 [==[ ... ]==]），见下面的字符串表示说明。

II.  Lua编程
　　经典的"Hello world"的程序总是被用来开始介绍一种语言。在Lua中，写一个这样的程序很简单：
　　print("Hello world")
　　在Lua中，语句之间可以用分号"；"隔开，也可以用空白隔开。一般来说，如果多个语句写在同一行的话，建议总是用分号隔开。
　　Lua 有好几种程序控制语句，如：
控制语句格式示例
Ifif 条件 then ... elseif 条件 then ... else ... end
if 1+1=2 then print("true")
elseif 1+2~=3 then print("true")
else print("false") end

Whilewhile 条件 do ... end
while 1+1~=2 do print("true") end

Repeatrepeat ... until 条件
repeat print("Hello") until 1+1~=2

Forfor 变量=初值, 终点值, 步进 do ... end
for i = 1, 10, 2 do print(i) end

Forfor 变量1, 变量2, ... 变量n in 表或枚举函数 do ... end
for a,b in mylist do print(a, b) end


　　注意一下，for的循环变量总是只作用于for的局部变量；当省略步进值时，for循环会使用1作为步进值。
　　使用break可以用来中止一个循环。
　　相对C语言来说，Lua有几个地方是明显不同的，所以面要特别注意一下：

　　．语句块
　　　　语句块在C中是用"{"和"}"括起来的，在Lua中，它是用do 和 end 括起来的。比如：
　　　　do print("Hello") end
　　　　可以在 函数 中和 语句块 中定局部变量。

　　．赋值语句
　　　　赋值语句在Lua被强化了。它可以同时给多个变量赋值。
　　　　例如：
　　　　a,b,c,d=1,2,3,4
　　　　甚至是：
　　　　a,b=b,a  -- 多么方便的交换变量功能啊。
　　　　在默认情况下，变量总是认为是全局的。假如需要定义局部变量，则在第一次赋值的时候，需要用local说明。比如：
　　　　local a,b,c = 1,2,3  -- a,b,c都是局部变量

　　．数值运算
　　　　和C语言一样，支持 +, -, *, /。但Lua还多了一个"^"。这表示指数乘方运算。比如2^3 结果为8, 2^4结果为16。
　　　　连接两个字符串，可以用".."运处符。如：
　　　　"This a " .. "string." -- 等于 "this a string"

　　．比较运算
比较符号<><=>===~=
含义小于大于小于或等于大于或等于相等不相等

　　　　所有这些操作符总是返回true或false。
　　　　对于Table，Function和Userdata类型的数据，只有 == 和 ~=可以用。相等表示两个变量引用的是同一个数据。比如：
　　　　a={1,2}
　　　　b=a
　　　　print(a==b, a~=b)  --输出 true, false
　　　　a={1,2}
　　　　b={1,2}
　　　　print(a==b, a~=b)  --输出 false, true


　　．逻辑运算
　　　　and, or, not
　　　　其中，and 和 or 与C语言区别特别大。
　　　　在这里，请先记住，在Lua中，只有false和nil才计算为false，其它任何数据都计算为true，0也是true！
　　　　and 和 or的运算结果不是true和false，而是和它的两个操作数相关。
　　　　a and b：如果a为false，则返回a；否则返回b
　　　　a or b：如果 a 为true，则返回a；否则返回b

　　　　举几个例子：
　　　　 print(4 and 5) --输出 5
　　　　 print(nil and 13) --输出 nil
　　　　 print(false and 13) --输出 false
　　　　 print(4 or 5) --输出 4
　　　　 print(false or 5) --输出 5

　　　　在Lua中这是很有用的特性，也是比较令人混洧的特性。
　　　　我们可以模拟C语言中的语句：x = a? b : c，在Lua中，可以写成：x = a and b or c。
　　　　最有用的语句是： x = x or v，它相当于：if not x then x = v end 。

　　．运算符优先级，从低到高顺序如下：
     or
     and
     <     >     <=    >=    ~=    ==
     .. (字符串连接)
     +     -
     *     /     %
     not   #(lua5.1 取长度运算)     - (一元运算)
     ^
和C语言一样，括号可以改变优先级。

III.  关键字
　　关键字是不能做为变量的。Lua的关键字不多，就以下几个：
    
andbreakdoelseelseif
endfalseforfunctionif
inlocalnilnotor
repeatreturnthentrueuntilwhile

IV.  变量类型
　　怎么确定一个变量是什么类型的呢？大家可以用type()函数来检查。Lua支持的类型有以下几种：
Nil空值，所有没有使用过的变量，都是nil。nil既是值，又是类型。
Boolean布尔值，只有两个有效值：true和false
Number数值，在Lua里，数值相当于C语言的double
String字符串，如果你愿意的话，字符串是可以包含"\0"字符的（这和C语言总是以"\0"结尾是不一样的）
Table关系表类型，这个类型功能比较强大，请参考后面的内容。
Function函数类型，不要怀疑，函数也是一种类型，也就是说，所有的函数，它本身就是一个变量。
Userdata嗯，这个类型专门用来和Lua的宿主打交道的。宿主通常是用C和C++来编写的，在这种情况下，Userdata可以是宿主的任意数据类型，常用的有Struct和指针。
Thread线程类型，在Lua中没有真正的线程。Lua中可以将一个函数分成几部份运行。如果感兴趣的话，可以去看看Lua的文档。
现在回过头来看看，倒觉得不是线程类型。反而象是用来做遍历的，象是Iterator函数。
如：
function range(n)
  local i = 0
  while(i < n) do
    coroutine.yield( i )
    i = i + 1
  end
end
可惜的是要继续运行，需要coroutine.resume函数，有点鸡肋。请指教。

V.  变量的定义
　　所有的语言，都要用到变量。在Lua中，不管在什么地方使用变量，都不需要声明，并且所有的这些变量总是全局变量，除非我们在前面加上"local"。这一点要特别注意，因为我们可能想在函数里使用局部变量，却忘了用local来说明。
　　至于变量名字，它是大小写相关的。也就是说，A和a是两个不同的变量。
　　定义一个变量的方法就是赋值。"＝"操作就是用来赋值的
　　我们一起来定义几种常用类型的变量吧。
　　A.  Nil
　　　　正如前面所说的，没有使用过的变量的值，都是Nil。有时候我们也需要将一个变量清除，这时候，我们可以直接给变量赋以nil值。如：
　　　　var1=nil  -- 请注意 nil 一定要小写

　　B.  Boolean
　　　　布尔值通常是用在进行条件判断的时候。布尔值有两种：true 和 false。在Lua中，只有false和nil才被计算为false，而所有任何其它类型的值，都是true。比如0，空串等等，都是true。不要被 C语言的习惯所误导，0在Lua中的的确确是true。你也可以直接给一个变量赋以Boolean类型的值，如：
　　　　theBoolean = true

　　C.  Number
　　　　在Lua中，是没有整数类型的，也不需要。一般情况下，只要数值不是很大（比如不超过100,000,000,000,000），是不会产生舍入误差的。在WindowsXP能跑的当今主流PC上，实数的运算并不比整数慢。
　　　　实数的表示方法，同C语言类似，如：
　　　　4 0.4 4.57e-3 0.3e12 5e+20

　　D.  String
　　　　字符串，总是一种非常常用的高级类型。在Lua中，我们可以非常方便的定义很长很长的字符串。
　　　　字符串在Lua中有几种方法来表示，最通用的方法，是用双引号或单引号来括起一个字符串的，如：
　　　　"That's go!"
　　　　或
　　　　'Hello world!'

　　　　和C语言相同的，它支持一些转义字符，列表如下：
　　　　\a  bell
　　　　\b  back space
　　　　\f  form feed
　　　　\n  newline
　　　　\r  carriage return
　　　　\t  horizontal tab
　　　　\v  vertical tab
　　　　\\  backslash
　　　　\"  double quote
　　　　\"  single quote
　　　　\[  left square bracket
　　　　\]  right square bracket

　　　　由于这种字符串只能写在一行中，因此，不可避免的要用到转义字符。加入了转义字符的串，看起来实在是不敢恭维，比如：
　　　　"one line\nnext line\n\"in quotes\", "in quotes""
　　　　一大堆的"\"符号让人看起来很倒胃口。如果你与我有同感，那么，我们在Lua中，可以用另一种表示方法：用"[["和"]]"将多行的字符串括起来。（lua5.1: 中括号中间可以加入若干个"="号，如 [==[ ... ]==]，详见下面示例）
　　　　示例：下面的语句所表示的是完全相同的字符串：
a = 'alo\n123"'
a = "alo\n123\""
a = '\97lo\10\04923"'
a = [[alo
123"]]
a = [==[
alo
123"]==]

　　　　值得注意的是，在这种字符串中，如果含有单独使用的"[["或"]]"就仍然得用"\["或"\]"来避免歧义。当然，这种情况是极少会发生的。

　　E.  Table
　　　　关系表类型，这是一个很强大的类型。我们可以把这个类型看作是一个数组。只是C语言的数组，只能用正整数来作索引；在Lua中，你可以用任意类型来作数组的索引，除了nil。同样，在C语言中，数组的内容只允许一种类型；在Lua中，你也可以用任意类型的值来作数组的内容，除了nil。
　　　　Table的定义很简单，它的主要特征是用"{"和"}"来括起一系列数据元素的。比如：
　　　　T1 = {}  -- 定义一个空表
　　　　T1[1]=10  -- 然后我们就可以象C语言一样来使用它了。

　　　　T1["John"]={Age=27, Gender="Male"}
　　　　这一句相当于：
　　　　T1["John"]={}  -- 必须先定义成一个表，还记得未定义的变量是nil类型吗
　　　　T1["John"]["Age"]=27
　　　　T1["John"]["Gender"]="Male"
　　　　当表的索引是字符串的时候，我们可以简写成：
　　　　T1.John={}
　　　　T1.John.Age=27
　　　　T1.John.Gender="Male"
　　　　或
　　　　T1.John{Age=27, Gender="Male"}
这是一个很强的特性。

　　　　在定义表的时候，我们可以把所有的数据内容一起写在"{"和"}"之间，这样子是非常方便，而且很好看。比如，前面的T1的定义，我们可以这么写：
　　　　T1=
　　　　{
　　　　　　10,  -- 相当于 [1] = 10
　　　　　　[100] = 40,
　　　　　　John=  -- 如果你原意，你还可以写成：["John"] =
　　　　　　{
　　　　　　　　Age=27,   -- 如果你原意，你还可以写成：["Age"] =27
　　　　　　　　Gender=Male   -- 如果你原意，你还可以写成：["Gender"] =Male
　　　　　　},
　　　　　　20  -- 相当于 [2] = 20
　　　　}

　　　　看起来很漂亮，不是吗？我们在写的时候，需要注意三点：
　　　　第一，所有元素之间，总是用逗号"，"隔开；
　　　　第二，所有索引值都需要用"["和"]"括起来；如果是字符串，还可以去掉引号和中括号；
　　　　第三，如果不写索引，则索引就会被认为是数字，并按顺序自动从1往后编；

　　　　表类型的构造是如此的方便，以致于常常被人用来代替配置文件。是的，不用怀疑，它比ini文件要漂亮，并且强大的多。

　　F.  Function
　　　　函数，在Lua中，函数的定义也很简单。典型的定义如下：
　　　　function add(a,b)  -- add 是函数名字，a和b是参数名字
　　　　 return a+b  -- return 用来返回函数的运行结果
　　　　end

　　　　请注意，return语言一定要写在end之前。假如我们非要在中间放上一句return，那么就应该要写成：do return end。
　　　　还记得前面说过，函数也是变量类型吗？上面的函数定义，其实相当于：
　　　　add = function (a,b) return a+b end
当重新给add赋值时，它就不再表示这个函数了。我们甚至可以赋给add任意数据，包括nil （这样，赋值为nil，将会把该变量清除）。Function是不是很象C语言的函数指针呢？

　　　　和C语言一样，Lua的函数可以接受可变参数个数，它同样是用"..."来定义的，比如：
　　　　function sum (a,b,)
如果想取得...所代表的参数，可以在函数中访问arg局部变量（表类型）得到 (lua5.1: 取消arg，并直接用"..."来代表可变参数了，本质还是arg)。
　　　　如 sum(1,2,3,4)
　　　　则，在函数中，a = 1, b = 2, arg = {3, 4}  (lua5.1:  a = 1, b = 2, ... = {3, 4})
　　　　更可贵的是，它可以同时返回多个结果，比如：
　　　　function s()
　　　　　　return 1,2,3,4
　　　　end
　　　　a,b,c,d = s()  -- 此时，a = 1, b = 2, c = 3, d = 4

　　　　前面说过，表类型可以拥有任意类型的值，包括函数！因此，有一个很强大的特性是，拥有函数的表，哦，我想更恰当的应该说是对象吧。Lua可以使用面向对象编程了。不信？举例如下：
　　　　t =
　　　　{
　　　　 Age = 27
　　　　 add = function(self, n) self.Age = self.Age+n end
　　　　}
　　　　print(t.Age)  -- 27
　　　　t.add(t, 10)
　　　　print(t.Age)  -- 37

　　　　不过，t.add(t,10) 这一句实在是有点土对吧？没关系，在Lua中，我们可以简写成：
　　　　t:add(10)    -- 相当于 t.add(t,10)

　　G.  Userdata 和 Thread
　　　　这两个类型的话题，超出了本文的内容，就不打算细说了。

VI.  结束语
　　就这么结束了吗？当然不是，接下来，我们需要用Lua解释器，来帮助理解和实践了。相信这样会更快的对Lua上手了。
　　就象C语言一样，Lua提供了相当多的标准函数来增强语言的功能。使用这些标准函数，可以很方便的操作各种数据类型，并处理输入输出。有关这方面的信息，我们可以参考《Programming in Lua 》一书，也可以在网络上直接观看电子版，网址为：http://www.lua.org/pil/index.html
　　
备注：本文的部份内容摘、译自lua随机文档。
相关链接：
1. Lua 官方网站： http://www.lua.org/
2. Lua Wiki网站，你可以在这里找到很多相关的资料，如文档、教程、扩展，以及C/C++的包装等： http://lua-users.org/wiki/
3. Lua 打包下载（包括各种平台和编译器的工程文件如vs2003,vs2005）：http://luabinaries.luaforge.net/download.html

这是我编译好的Lua5.02的解释器：http://www.cnblogs.com/Files/ly4cn/lua.zip

发表于： 分类于： 浏览：

下面的这些内容不包含在本文中：
官方的Lua包和文档 (参看 http://www.lua.org/),；
涉及到Lua使用但不是被Lua使用者普遍使用的东西 (参看 http://www.lua.org/uses.html), ；
本wiki已经存在的内容(参看 LuaDirectory).

类库和与Lua绑定的资源

LibrariesAndBindings

开发环境

  • [LuaIDE] (5.0) - Windows平台Lua的整合开发环境(最新发布 2004-01-29).
  • [wxLua] (5.0) - Lua and wxWidgets的混合体.有自己的带有调试器的IDE。这个IDE使用wxlua开发的。
  • [LuaEclipse] (5.0) - Eclipse 平台的Lua IDE .
  • [Vortex LuaIDE] (5.0) - Brazilian Portuguese的一些免费的Lua IDE! (Outra IDE para Lua gratuita, mas em Português!).
  • [LuaX] (5.x) - 支持多种操作系统下开发Lua应用的开发平台(with GUI, serial port etc. modules)特别适合于工业自动化和嵌入式产品开发。
  • [VisualWx] (5.x) - Lua & wxLua的IDE (自由软件)
  • [QDE] (5.x) - Lua的Quotix 开发环境. 他支持工程管理，多文档接口等 (最新发布2005-03-06).
  • [B:Lua] - 开源项目： 具备各种特征的Lua IDE.

代码封装

  • [CPB] (5.0)(Win32) - C++ 和 Lua连接之桥,实现两种语言的相互通信.
  • [CaLua] (5.0) - 实现了绑定C函数和结构体到Lua，可以在Lua中使用C指针、数组、函数。(使用x86结构的计算机)
  • [CppLua] (5.0) - lua API的C++封装。
  • [lua2c] (5.0) - 将Lua代码转换成C代码的工具.
  • [luabind] (5.0) - 基于模板的，绑定Lua和C++类以及函数
  • [tolua] (5.0) - 自动绑定C/C++和Lua的工具.
  • LuaWrapper 基于模版的封装包，很容易绑定C++代码和Lua。纯头文件。
  • [tolua++] (5.0) - tolua的高级版本，带有c++面向对象的特征. ( CompilingToluappWithoutScons i.e., Compiling Tolua++ Without SCons )
  • [luapi] (5.0) - Lua api的C封装.
  • [PBLua] (5.0.2) - Lua 5.0.2基本库的封装.
  • [PowerBLua] (5.0) - PowerBASIC include & source for wrapping Lua (work in progress).
  • [wxScript] (5.0.2) - 一些抽象类，添加到脚本解释器可以使你的wxWidgets支持Lua语言。
  • [LunaticPython] (0.1) - Lua/Python 的双向桥。可以将Lua解释器嵌入到python中，反过来也可以。

Lua的使用

Lua的使用列表[1].

  • [Premake] -一个用Lua语言实现的 automake 替代品. 可以为MS VC++, GNU make, 等创建工程文件.
  • [Lumikki] (5.0) - 使用Lua宏创建web站点，可以使用导航菜单，风格等。

工具

  • ExpLua (5.0) - 代码文档工具(开发中。。。).
  • [Hamster (ex SCons/Lua)] (5.x) - Lua front-end to the SCons build engine (or others).
  • [Kepler Project] (5.0) - 使用 [CGILua 5.0]实现的Lua 5.0的web模板引擎 .
  • [Mod_Lua (5.0)] -  Apache 2的 module，使得web应用与PHP类似。
  • [ctrace] (5.0) - 跟踪Lua API调用的工具.
  • [lper] (5.0) - 创建持久Lua 状态的工具, 基于 [GNU mmalloc] (part of GDB).
  • PlutoLibrary (5.0.2) - 为Lua创建重量级的持久性.
  • [ChunkSpy] (5.0.2) - a binary chunk disassembler, with interactive mode, reading custom binary chunk formats, etc.
  • [lua bakefile] (5.0.2) - 创建 LUA 工程的makefile和工程文件。
  • [tolua bakefile] (5.0.2) - 创建 TOLUA 工程的makefile和工程文件。
  • [ChunkBake] (5.0.2) - a line-oriented assembler for Lua 5 virtual machine instructions
  • [LuaSrcDiet] (5.0.2) - 通过删除不必要的空白和注释缩减Lua文件的大小。
  • [LuaProfiler] (5.0) - 一个用来查找Lua应用瓶颈的工具time profiler 。

See also LuaEditorSupport.

文档

发布版

See LuaBinaries for links to precompiled vanilla Lua 5.0 executables for various platforms. Real binaries (without addons) should move from here to there.

  • [LuaCheia] (5.0) - Lua 5.0 for GNU/Linux, Mac/OS X, Windows, *BSD, Solaris, etc. Includes many add-on binary modules.
  • [LuaPlus] (5.0) - C++ enhancements and various extensions to core Lua functionality
  • [Linux RPMs] (5.0) - i386 binary, source and spec file for Lua 5.0.2
  • [RPMs for Lua] (5.0) - from Rpmfind.Net.
  • [RPMs with Lua modules]
  • [Lua 5 for EPOC] (5.0) - Lua 5.0.1 for Symbian OS v1-5.
  • [LuaCE] (5.0) - additional source files for compiling Lua for Windows CE.
  • [LuaPPC] (5.0) - Stand-alone Lua 5.0 interpreter for the Pocket PC. (Built using LuaCE above.)
  • [LuaPocket] (5.0) - Stand-alone Lua 5.0 interpreter for the Pocket PC with graphic support. (Built using LuaPPC above.)
  • [Lua for RISC OS] (5.0)
  • [Lua for Palm OS] (5.0) Port of Lua for Palm (in alpha).
  • [Lua89] (5.0) Experimental port of Lua to the TI89 graphing calculator.

其他的一些Lua实现方式

  • [Sol] - Lua 的派生物.
  • [Lua.NET] .net相关的Lua
  • [LuaLeo] -  根据[Leonardo VM] 实现的Lua 3.1
  • [Lua-ML] -  由面向对象的Caml实现的 Lua 2.5
  • [Yindo] - Lua 的实现，作为OpenGL 浏览器插件(很快过时了)
  • [Yueliang] (5.0.2) - 使用Lua实现Lua，包括词法解析、语法解析、代码生成和生成二进制chunks.

发表于： 分类于： 浏览：

发表于： 更新于： 分类于： 浏览：

大家知道，Windows NT/2000为实现其可靠性，严格将系统划分为内核模式与用户模式，在i386系统中分别对应CPU的Ring0与Ring3级别。Ring0下，可以执行特权级指令，对任何I/O设备都有访问权等等。要实现从用户态进入核心态，即从Ring 3进入Ring 0必须借助CPU的某种门机制，如中断门、调用门等。而Windows NT/2000提供用户态执行系统服务(Ring 0例程)的此类机制即System Service的int 2eh中断服务等，严格的参数检查，只能严格的执行Windows NT/2000提供的服务，而如果想执行用户提供的Ring 0代码(指运行在Ring 0权限的代码)，常规方法似乎只有编写设备驱动程序。本文将介绍一种在用户态不借助任何驱动程序执行Ring0代码的方法。

    Windows NT/2000将设备驱动程序调入内核区域(常见的位于地址0x80000000上)，由DPL为0的GDT项8，即cs为8时实现Ring 0权限。本文通过在系统中构造一个指向我们的代码的调用门(CallGate)，实现Ring0代码。基于这个思路，为实现这个目的主要是构造自己的CallGate。CallGate由系统中叫Global Descriptor Table(GDT)的全局表指定。GDT地址可由i386指令sgdt获得(sgdt不是特权级指令，普通Ring 3程序均可执行)。GDT地址在Windows NT/2000保存于KPCR(Processor Control Region)结构中(见《再谈Windows NT/2000环境切换》)。GDT中的CallGate是如下的格式：

    typedef struct
    {
        unsigned short  offset_0_15;
        unsigned short  selector;

        unsigned char    param_count : 4;
        unsigned char    some_bits   : 4;

        unsigned char    type        : 4;
        unsigned char    app_system  : 1;
        unsigned char    dpl         : 2;
        unsigned char    present     : 1;
    
        unsigned short  offset_16_31;
    } CALLGATE_DESCRIPTOR;

    GDT位于内核区域，一般用户态的程序是不可能对这段内存区域有直接的访问权。幸运的是Windows NT/2000提供了一个叫PhysicalMemory的Section内核对象位于\Device的路径下。顾名思义，通过这个Section对象可以对物理内存进行操作。用objdir.exe对这个对象分析如下：

    C:\NTDDK\bin>objdir /D \Device

    PhysicalMemory                   
        Section
        DACL - 
           Ace[ 0] - Grant - 0xf001f - NT AUTHORITY\SYSTEM
                             Inherit: 
                             Access: 0x001F  and  ( D RCtl WOwn WDacl )

           Ace[ 1] - Grant - 0x2000d - BUILTIN\Administrators
                             Inherit: 
                             Access: 0x000D  and  ( RCtl )

    从dump出的这个对象DACL的Ace可以看出默认情况下只有SYSTEM用户才有对这个对象的读写权限，即对物理内存有读写能力，而Administrator只有读权限，普通用户根本就没有权限。不过如果我们有Administrator权限就可以通过GetSecurityInfo、SetEntriesInAcl与SetSecurityInfo这些API来修改这个对象的ACE。这也是我提供的代码需要Administrator的原因。实现的代码如下：

    VOID SetPhyscialMemorySectionCanBeWrited(HANDLE hSection)
    {

       PACL pDacl=NULL;
       PACL pNewDacl=NULL;
       PSECURITY_DESCRIPTOR pSD=NULL;
       DWORD dwRes;
       EXPLICIT_ACCESS ea;

       if(dwRes=GetSecurityInfo(hSection,SE_KERNEL_OBJECT,DACL_SECURITY_INFORMATION,
                  NULL,NULL,&pDacl,NULL,&pSD)!=ERROR_SUCCESS)
          {
             printf( “GetSecurityInfo Error %u\n”, dwRes );
             goto CleanUp;
          }

       ZeroMemory(&ea, sizeof(EXPLICIT_ACCESS));
       ea.grfAccessPermissions = SECTION_MAP_WRITE;
       ea.grfAccessMode = GRANT_ACCESS;
       ea.grfInheritance= NO_INHERITANCE;
       ea.Trustee.TrusteeForm = TRUSTEE_IS_NAME;
       ea.Trustee.TrusteeType = TRUSTEE_IS_USER;
       ea.Trustee.ptstrName = “CURRENT_USER”;


       if(dwRes=SetEntriesInAcl(1,&ea,pDacl,&pNewDacl)!=ERROR_SUCCESS)
          {
             printf( “SetEntriesInAcl %u\n”, dwRes );
             goto CleanUp;
          }

       if(dwRes=SetSecurityInfo(hSection,SE_KERNEL_OBJECT,DACL_SECURITY_INFORMATION,NULL,NULL,pNewDacl,NULL)!=ERROR_SUCCESS)
          {
             printf(“SetSecurityInfo %u\n”,dwRes);
             goto CleanUp;
          }

    CleanUp:

       if(pSD)
          LocalFree(pSD);
       if(pNewDacl)
          LocalFree(pSD);
    }

    这段代码对给定HANDLE的对象增加了如下的ACE:

    PhysicalMemory                   
        Section
        DACL - 
           Ace[ 0] - Grant - 0x2 - WEBCRAZY\Administrator
                             Inherit: 
                             Access: 0x0002    //SECTION_MAP_WRITE

    这样我们在有Administrator权限的条件下就有了对物理内存的读写能力。但若要修改GDT表实现Ring 0代码。我们将面临着另一个难题，因为sgdt指令获得的GDT地址是虚拟地址(线性地址)，我们只有知道GDT表的物理地址后才能通过\Device\PhysicalMemory对象修改GDT表，这就牵涉到了线性地址转化成物理地址的问题。我们先来看一看Windows NT/2000是如何实现这个的：

    kd> u nt!MmGetPhysicalAddress l 30
    ntoskrnl!MmGetPhysicalAddress:
    801374e0 56               push    esi
    801374e1 8b742408         mov     esi,[esp+0x8]
    801374e5 33d2             xor     edx,edx
    801374e7 81fe00000080     cmp     esi,0x80000000
    801374ed 722c             jb    ntoskrnl!MmGetPhysicalAddress+0x2b (8013751b)
    801374ef 81fe000000a0     cmp     esi,0xa0000000
    801374f5 7324             jnb   ntoskrnl!MmGetPhysicalAddress+0x2b (8013751b)
    801374f7 39153ce71780     cmp     [ntoskrnl!MmKseg2Frame (8017e73c)],edx
    801374fd 741c             jz    ntoskrnl!MmGetPhysicalAddress+0x2b (8013751b)
    801374ff 8bc6             mov     eax,esi
    80137501 c1e80c           shr     eax,0xc
    80137504 25ffff0100       and     eax,0x1ffff
    80137509 6a0c             push    0xc
    8013750b 59               pop     ecx
    8013750c e8d3a7fcff       call    ntoskrnl!_allshl (80101ce4)
    80137511 81e6ff0f0000     and     esi,0xfff
    80137517 03c6             add     eax,esi
    80137519 eb17             jmp   ntoskrnl!MmGetPhysicalAddress+0x57 (80137532)
    8013751b 8bc6             mov     eax,esi
    8013751d c1e80a           shr     eax,0xa
    80137520 25fcff3f00       and     eax,0x3ffffc
    80137525 2d00000040       sub     eax,0x40000000
    8013752a 8b00             mov     eax,[eax]
    8013752c a801             test    al,0x1
    8013752e 7506             jnz   ntoskrnl!MmGetPhysicalAddress+0x44 (80137536)
    80137530 33c0             xor     eax,eax
    80137532 5e               pop     esi
    80137533 c20400           ret     0x4

    从这段汇编代码可看出如果线性地址在0x80000000与0xa0000000范围内，只是简单的进行移位操作(位于801374ff-80137519指令间)，并未查页表。我想Microsoft这样安排肯定是出于执行效率的考虑。这也为我们指明了一线曙光，因为GDT表在Windows NT/2000中一般情况下均位于这个区域(我不知道/3GB开关的Windows NT/2000是不是这种情况)。

    经过这样的分析，我们就可以只通过用户态程序修改GDT表了。而增加一个CallGate就不是我可以介绍的了，找本Intel手册自己看一看了。具体实现代码如下：

    typedef struct gdtr {
        short Limit;
        short BaseLow;
        short BaseHigh;
    } Gdtr_t, PGdtr_t;

    ULONG MiniMmGetPhysicalAddress(ULONG virtualaddress)
    {
        if(virtualaddress<0x80000000||virtualaddress>=0xA0000000)
           return 0;
        return virtualaddress&0x1FFFF000;
    }

    BOOL ExecRing0Proc(ULONG Entry,ULONG seglen)
    {
       Gdtr_t gdt;
       __asm sgdt gdt;
     
       ULONG mapAddr=MiniMmGetPhysicalAddress(gdt.BaseHigh<<16U|gdt.BaseLow);
       if(!mapAddr) return 0;

       HANDLE   hSection=NULL;
       NTSTATUS status;
       OBJECT_ATTRIBUTES        objectAttributes;
       UNICODE_STRING objName;
       CALLGATE_DESCRIPTOR cg;

       status = STATUS_SUCCESS;
   
       RtlInitUnicodeString(&objName,L"\Device\PhysicalMemory");

       InitializeObjectAttributes(&objectAttributes,
                                  &objName,
                                  OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                                  NULL,
                                 (PSECURITY_DESCRIPTOR) NULL);

       status = ZwOpenSection(&hSection,SECTION_MAP_READ|SECTION_MAP_WRITE,&objectAttributes);

       if(status == STATUS_ACCESS_DENIED){
          status = ZwOpenSection(&hSection,READ_CONTROL|WRITE_DAC,&objectAttributes);
          SetPhyscialMemorySectionCanBeWrited(hSection);
          ZwClose(hSection);
          status =ZwOpenSection(&hSection,SECTION_MAP_WRITE|SECTION_MAP_WRITE,&objectAttributes);
       }

       if(status != STATUS_SUCCESS)
         {
            printf(“Error Open PhysicalMemory Section Object,Status:%08X\n”,status);
            return 0;
         }
      
       PVOID BaseAddress;

       BaseAddress=MapViewOfFile(hSection,
                     FILE_MAP_READ|FILE_MAP_WRITE,
                     0,
                     mapAddr,    //low part
                     (gdt.Limit+1));

       if(!BaseAddress)
          {
             printf(“Error MapViewOfFile:”);
             PrintWin32Error(GetLastError());
             return 0;
          }

       BOOL setcg=FALSE;

       for(cg=(CALLGATE_DESCRIPTOR )((ULONG)BaseAddress+(gdt.Limit&0xFFF8));(ULONG)cg>(ULONG)BaseAddress;cg–)
           if(cg->type == 0){
             cg->offset_0_15 = LOWORD(Entry);
             cg->selector = 8;
             cg->param_count = 0;
             cg->some_bits = 0;
             cg->type = 0xC;          // 386 call gate
             cg->app_system = 0;      // A system descriptor
             cg->dpl = 3;             // Ring 3 code can call
             cg->present = 1;
             cg->offset_16_31 = HIWORD(Entry);
             setcg=TRUE;
             break;
          }

       if(!setcg){
            ZwClose(hSection);
            return 0;
       }

       short farcall[3];

       farcall[2]=((short)((ULONG)cg-(ULONG)BaseAddress))|3;  //Ring 3 callgate;

       if(!VirtualLock((PVOID)Entry,seglen))
          {
             printf(“Error VirtualLock:”);
             PrintWin32Error(GetLastError());
             return 0;
          }

       SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_TIME_CRITICAL);

       Sleep(0);

       _asm call fword ptr [farcall]

       SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_NORMAL);

       VirtualUnlock((PVOID)Entry,seglen);

       //Clear callgate
       (ULONG )cg=0;
       ((ULONG *)cg+1)=0;

       ZwClose(hSection);
       return TRUE;

    }

    我在提供的代码中演示了对Control Register与I/O端口的操作。CIH病毒在Windows 9X中就是因为获得Ring 0权限才有了一定的危害，但Windows NT/2000毕竟不是Windows 9X，她已经有了比较多的安全审核机制，本文提供的代码也要求具有Administrator权限，但如果系统存在某种漏洞，如缓冲区溢出等等，还是有可能获得这种权限的，所以我不对本文提供的方法负有任何的责任，所有讨论只是一个技术热爱者在讨论技术而已。谢谢！ 

    参考资料：
      1.Intel Corp<<Intel Architecture Software Developer’s Manual,Volume 3>>  


代码下载:http://www.cnblogs.com/Files/flying_bat/ntring0.zip

发表于： 分类于： 浏览：

本篇是{% post_link alpha-color-blending-in-D3D-2 “D3D中的Alpha颜色混合（2）” %}的后续篇。

另一种实现实现背景透明显示的简便方法是直接应用渲染管道流水线的Alpha测试功能进行，{% post_link alpha-color-blending-in-D3D-2 “D3D中的Alpha颜色混合（2）” %}介绍的接口方法实际就是对Alpha测试的一个包装。Alpha测试是对需要写入绘图表面的像素颜色Alpha值进行测试，判断该Alpha值是否满足预先设定的条件，如果满足条件，则将该像素颜色值写入绘图表面，否则不写入。

发表于： 分类于： 浏览：

渲染管道流水线通常需要将来自顶点的颜色，纹理像素的颜色，光照颜色以及物体表面材质反射光颜色进行混合，生成计算机屏幕的像素颜色。将多种颜色混合在一起，必须考虑各种颜色的成分比例，这个比例由Alpha因子决定。对于游戏开发来说，利用Alpha颜色混合可产生背景透明的渲染效果。

发表于： 分类于： 浏览：

代码共享如下，在Win2K sp4/WinXP sp2上调试通过。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

BOOL CheckFileTrust( LPCWSTR lpFileName )
{
        BOOL bRet = FALSE;
    WINTRUST_DATA wd = { 0 };
    WINTRUST_FILE_INFO wfi = { 0 };
    WINTRUST_CATALOG_INFO wci = { 0 };
    CATALOG_INFO ci = { 0 };

    HCATADMIN hCatAdmin = NULL;
    <FONT color=blue>if</FONT> ( !CryptCATAdminAcquireContext( &amp;hCatAdmin, NULL, 0 ) )
    {
            <FONT color=blue>return</FONT> FALSE;
    }

    HANDLE hFile = CreateFileW( lpFileName, GENERIC_READ, FILE_SHARE_READ,
        NULL, OPEN_EXISTING, 0, NULL );
    <FONT color=blue>if</FONT> ( INVALID_HANDLE_VALUE == hFile )
    {
            CryptCATAdminReleaseContext( hCatAdmin, 0 );
        <FONT color=blue>return</FONT> FALSE;
    }

    DWORD dwCnt = 100;
    BYTE byHash[100];
    CryptCATAdminCalcHashFromFileHandle( hFile, &amp;dwCnt, byHash, 0 );
    CloseHandle( hFile );

    LPWSTR pszMemberTag = <FONT color=blue>new</FONT> WCHAR[dwCnt * 2 + 1];
    <FONT color=blue>for</FONT> ( DWORD dw = 0; dw &lt; dwCnt; ++dw )
    {
            wsprintfW( &amp;pszMemberTag[dw * 2], L"%02X", byHash[dw] );
    }

    HCATINFO hCatInfo = CryptCATAdminEnumCatalogFromHash( hCatAdmin,
        byHash, dwCnt, 0, NULL );
    <FONT color=blue>if</FONT> ( NULL == hCatInfo )
    {
            wfi.cbStruct       = <FONT color=blue>sizeof</FONT>( WINTRUST_FILE_INFO );
        wfi.pcwszFilePath  = lpFileName;
        wfi.hFile          = NULL;
        wfi.pgKnownSubject = NULL;

        wd.cbStruct            = <FONT color=blue>sizeof</FONT>( WINTRUST_DATA );
        wd.dwUnionChoice       = WTD_CHOICE_FILE;
        wd.pFile               = &amp;wfi;
        wd.dwUIChoice          = WTD_UI_NONE;
        wd.fdwRevocationChecks = WTD_REVOKE_NONE;
        wd.dwStateAction       = WTD_STATEACTION_IGNORE;
        wd.dwProvFlags         = WTD_SAFER_FLAG;
        wd.hWVTStateData       = NULL;
        wd.pwszURLReference    = NULL;
    }
    <FONT color=blue>else</FONT>
    {
            CryptCATCatalogInfoFromContext( hCatInfo, &amp;ci, 0 );
        wci.cbStruct             = <FONT color=blue>sizeof</FONT>( WINTRUST_CATALOG_INFO );
        wci.pcwszCatalogFilePath = ci.wszCatalogFile;
        wci.pcwszMemberFilePath  = lpFileName;
        wci.pcwszMemberTag       = pszMemberTag;

        wd.cbStruct            = <FONT color=blue>sizeof</FONT>( WINTRUST_DATA );
        wd.dwUnionChoice       = WTD_CHOICE_CATALOG;
        wd.pCatalog            = &amp;wci;
        wd.dwUIChoice          = WTD_UI_NONE;
        wd.fdwRevocationChecks = WTD_STATEACTION_VERIFY;
        wd.dwProvFlags         = 0;
        wd.hWVTStateData       = NULL;
        wd.pwszURLReference    = NULL;
    }
    GUID action = WINTRUST_ACTION_GENERIC_VERIFY_V2;
    HRESULT hr  = WinVerifyTrust( NULL, &amp;action, &amp;wd );
    bRet        = SUCCEEDED( hr );

    <FONT color=blue>if</FONT> ( NULL != hCatInfo )
    {
            CryptCATAdminReleaseCatalogContext( hCatAdmin, hCatInfo, 0 );
    }
    CryptCATAdminReleaseContext( hCatAdmin, 0 ); <FONT color=green>// 2007.4.10感谢童志明君指出一处内存泄漏</FONT>
    <FONT color=blue>delete</FONT>[] pszMemberTag;
    <FONT color=blue>return</FONT> bRet;
}

这段代码是在一个老外的论坛上不经意搜索到的，一个貌似德国人（因为他的注释不是英文写的，德国亦仅猜测尔，西班牙、葡萄牙、法兰西、俄罗斯亦都有可能）写的Delphi代码，其中使用了WinTrust.dll中的导出函数。使用VS2005的朋友们可以包含WinTrust.h、SoftPub.h和Mscat.h，并添加导入库WinTrust.lib；使用VC6的朋友们可以参考MSDN上的函数及结构体声明，并用函数指针进行调用。

发表于： 分类于： 浏览：

我要做自己情绪的主人！

潮起潮落、冬去春来、月圆月缺、花飞花谢，自然界万物都在循环往复的变化之中，我也不例外，情绪会时好时坏。每天清晨醒来时，我可能不再有旧日的情怀。昨日的欢乐变成今日的哀愁，今日的悲伤又转为明日的喜悦。我的心像车轮般不停地旋转：由乐而悲，由悲而喜，由喜而忧。这就好比花儿的变化，今日绽放时的喜悦终将变成明天凋谢时的绝望。但是我要牢牢记住：正如今天枯败的花儿蕴藏着明天新生的种子，今天的悲伤也预示着明日的欢乐。

我要做自己情绪的主人！

我怎样才能控制自己的情绪，使我的每一天卓有成效？我只知道这样一个事实：无论我为他人带来的是风雨、忧郁、黑暗和悲观，还是欢乐、喜悦、光明和笑声，他们都会以同样而报之。花草树木，随着气候的变化而生长，而我要为自己创造天气，学会用自己的心灵弥补气候的不足。我必须得心平气和，否则迎来的又将是失败的一天。

我要做自己情绪的主人！

我怎样才能控制自己的情绪，让我的每一天充满幸福和欢乐？我要学会这个千古秘诀：弱者任思绪控制行为，强者让行为控制思绪。每天醒来当我被悲伤、自怜、失败的情绪包围时，我就这样与之对抗：沮丧时，我引亢高歌；悲伤时，我开怀大笑；病痛时，我加倍工作；恐惧时，我勇往直前；自卑时，我换上新装；不安时，我提高嗓音；穷困潦倒时，我想象未来的富有；力不从心时，我回想过去的成功；自轻自贱时，我想想自己的目标。

我要做自己情绪的主人！

从今往后，我必须不断对抗那些企图摧垮我的力量。失望与悲伤一眼就可识破，而那些不易觉察、面带微笑、招手而来的敌人，却随时可能将我摧毁。对它们，我永远不能放松警惕：自高自大时，我要追寻失败的记忆；洋洋得意时，我要想想竞争的对手；沾沾自喜时，不要忘了那忍辱的时刻；自以为是时，看看自己能否让风止步；骄傲自满时，要想到自己怯懦的时候；不可一世时，抬起头来，仰望天上群星。

我要做自己情绪的主人！

有了这项本领，我就能体察别人的情绪变化。我会宽容怒气冲冲的人，因为他尚未懂得控制自己的情绪；我能忍受他人的指责与辱骂，因为知道明天他会重新变得随和。我不再只凭一面之交来判断他人，也不再因一时的怨恨与人绝交。今天不肯花一分钱购买金蓬马车的人，明天也许会用全部家当换取树苗。知道了这个秘密，我对人可以宽容大度，对事能够冷静客观。

我要做自己情绪的主人！

我从此领悟了人类情绪变化的奥秘。对于自己千变万化的个性，我不再听之任之，我知道，只有积极主动地控制情绪，才能掌握自己的命运。我成为自己情绪的主人，我由此而变得伟大。

我要做自己情绪的主人！