关键字：传统反病毒引擎 云查杀引擎 蚂蚁引擎 梦幻引擎

传统反病毒引擎目前发展的瓶颈在于特征码增长无法适应病毒增长，无论是反映速度、匹配速度、升级速度都捉襟见肘。

按照我的理解，反病毒引擎发展史可划分为几个阶段，80年代末－90年代末是第一阶段，主要是DOS平台下的反病毒引擎；90年代末－2004年是第二阶段，这是在windows平台下以特征码匹配为基础的传统反病毒引擎的辉煌时期；04年之后到现在，是反病毒引擎多元化发展的时期，这是时期的重要特点就是病毒数量每年的增长基本是前几年的总和。

任何一个技术都有其自身生命周期，特别在软件领域，基本“各领风骚十几年”。传统的引擎也是如此，而目前对于互联网发展滞后，具体表现在：
1. 病毒太多，处理不彻底。
2. 病毒生命周期变短，导致传统反病毒引擎特征码大部分是“垃圾”或者“死特征”。
3. 病毒相应速度滞后。
4. 反病毒软件运行速度下降。

自07年以来，“云”查毒概念产生了，各大反病毒厂商开始研发“云”查杀引擎，于传统引擎不同，它的特点如下：
1. 区别于传统引擎的本质在于特征码的匹配，不在客户端，而是集中在服务器端。
2. 特征码趋于简单化。
3. 反映速度块，由于在服务器端，几乎在判断第一个病毒的同时，可以判断其他计算机上的病毒。
4. 缺点很明显，怕断网。
5. 查杀速度不见得优于传统引擎，特征码质量也不见得优于传统引擎，量多了质下降了。

如果说引擎是活的化，那么完全可以分散开来，迅雷可以均衡互助下载，我们为什么不能？但绝不是“蚂蚁引擎”，那只能是相当与“病毒蚂蚁”，搞不好会造成更糟的结果。

我所说想象的反病毒大同世界，或者说是梦幻引擎如下：
1. 有大脑，即服务器端；有蚂蚁云，即客户端，由服务器端统一号令，不是各自乱窜，而是统一调配。
2. 传统反病毒引擎拆分，运算特征码部分（包含解压、脱壳等等）划分客户端，匹配特征码部分划分服务器端，但要保留客户端一定数量的流行病毒特征。
3. 反病毒引擎可以以实体存在，但更简单快捷的方式是访问反病毒网页，直接杀毒，类似google有网页word，那么我们完全可以网页反病毒，仅有一点就是需要上网，但绝不是象“在线杀毒”那样下载病毒库，而是直接匹配杀毒。

是的，这是个活生生的“反病毒生物体”，客户端是“抗体”，通过互联网这个“血管”联系起来，由服务器的“大脑”统一指挥。
                                                                                                          

                                                                                                                         2009-10-9 凌晨 似醒非醒态

vs2005调试32位汇编时，依然象vc6一样支持_asm关键字，但是64位不支持。我们可以用另外一种方法，把汇编写成一个asm文件，和cpp一块调试而不是直接嵌入_asm。这种方法微软的实例已经给出：

vs2005调试32位汇编源码

https://sites.google.com/site/aiwulu/avengine/C%26ASM_32_20090828_blog.rar?attredirects=0

vs2005调试64位汇编源码（略有修改）

https://sites.google.com/site/aiwulu/avengine/C&ASM_64_20090828_blog.rar?attredirects=0

这种方法的本质是利用了链接程序，cpp用cl调试，asm用ml调试，然后用link链接。事实上，我们可以直接在vs2005工程中加入一个obj直接调试，你有没有什么启发？

大约在03年时看到bochs有反汇编的源码，支持x86系列16位和32位。bochs的早期，反汇编的原理和其指令系统一致，都是利用的指令类型，即这张表：

https://sites.google.com/site/aiwulu/avengine/80386Programmer%27sReferenceManual--AppendixA.rar?attredirects=0

新版本更新后，反汇编改为了查表的方式，并且支持了64位。

反汇编用的最多的是读取指令的长度，这个可以用在hook，脱壳等程序中；还有一个是根据这些静态指令判断花指令等，但最根本的还是反汇编源码。

Bochs的源码有个特点就是与时俱进，并且代码模块整齐，基本不调用函数。修改也很容易，如果只想读取指令长度，可以注释里面的生成反汇编字符串部分，加快速度。

源码：

https://sites.google.com/site/aiwulu/avengine/Disasm_64_20090828_blog.rar?attredirects=0

新国图二期不错，环境好，MM多，还能免费上网下论文，实在是美不胜收。阳光透过天窗洒在身上，感觉自然不必说，这程序的一部分就是在那儿写的，好坏不论，单是这过程也是享受啊。

下载地址：

http://sites.google.com/site/aiwulu/avengine/Ldump_V1.1.rar?attredirects=0

程序说明：

LDump 是一个对PE文件操作的工具，主要功能如下：

1.识别部分PE文件是的编译选项，区分判断debug,release版本。历来vc编译的程序调试发行版本不好区分，一般采取IDA反编译源码比较识别，我把一些共同的特征提取出来做了这个功能，或许会有所帮助。另外，我还区分了编译器版本（vc6.0 vs2001 vs2003 vs2005 vs2008）、调试版本(debug release)、入口类型(main wmain WinMain wWinMain DllMain)、单线程多线程(Single-Thread Multi-Thread)、连接库(libc libcd libcmt libcmtd msvcrt msvcrtd)的信息。其实这些都是联系在一起的，编译器首先根据代码的入口方式、编译选项编译obj，然后再选择用那个库链接生成pe。说个题外话，刘涛涛的“扭曲变换加密”就是在这个链接库上做的文章，先把lib展开，一个一个变形后重新压成新的lib，然后链接代码就可以了，主代码的obj也需要变换，当然我们不希望看到病毒也这么做。说这么多是因为这些都是反病毒引擎的基础之一，需要深入理解。
2.显示对齐后的节表。
3.生成虚拟地址和物理地址相同的新文件，免去分析文件时地址转换的繁琐。

示例：

命令：ldump localui.dll
File Type             PE VS2001 Release DllMain Multi-T libcmt.lib

命令：LDump test.exe
#   Name          VirtSize    RVA     PhysSize Phys off Flags
-- --------      -------- -------- -------- -------- --------
00 UPX0          0000E000 00001000 00002E00 00000400 E0000080 [ERUW]
01 UPX1          00003000 0000F000 00002E00 00000400 E0000040 [EIRW*]
02 UPX2          00001000 00012000 00000200 00003200 C0000040 [IRW]

命令：LDump /l test.exe 后生成test.exe_文件，节表如下
#   Name          VirtSize    RVA     PhysSize Phys off Flags
-- --------      -------- -------- -------- -------- --------
00 UPX0          0000E000 00001000 0000E000 00001000 E0000080 [ERUW]
01 UPX1          00003000 0000F000 00003000 0000F000 E0000040 [EIRW*]
02 UPX2          00001000 00012000 00001000 00012000 C0000040 [IRW]

启发：很久很久以前的思想，最早是kv300中的广谱和avp的ca。

虚拟机：从92年avp实现emul,至97年刘涛涛的tr，到目前泛滥的程度。

新的杀毒技术是什么？是综合的技术而不是单纯的技术，或者说这个技术到头来只是个技术，你充其量也就是个能工巧匠而已，要想从雕刻匠变为齐白石，那就抛弃这些所谓的技术吧。
                                                                                                                            2008.6.4

若f为函数，满射非单射为上；双射次之；非满射非单射再次；非满射单射最末。

若f非函数，A全命中为上；否则一对一为上，一对多为下。

A中病毒是否命中为最本质区别，无论采用什么技术，其次特征码冗余度小为善，再次为速度等。

2.       明白什么样的文件可能会产生什么样的病毒。

3.       明白扫描什么时不需要扫描什么。

4.       明白什么样的算法更适合引擎。

5.       明白cache的重要性。

6.       明白多核和多引擎的关系。

7.       明白虚拟机的适用范围。

8.       …

速度是衡量杀毒引擎优劣的基本指标之一。

1.       引导地址冷启动；

2.       禁用中断、装入DS及使IDT为空；

3.       建立GDT及LGDT；

4.       进入32为代码的保护方式；

5.       转入段寄存器；

6.       建立LDT、LLDT；

7.       建立IDT、LIDT；

8.       建立页目录；

9.       建立页表；

10.   启动分页机制；

11.   装入OS栈；

12.   建立TSS、LTR；

13.   装入用户任务；

14.   为调用用户任务做准备；

15.   调用用户任务；

选至《保护方式下的80386及其编程》，周明德主编，田云、何德书、宗耀堂编著，P409。

这是一本好书！现在的书越来越多，但好书越来越少了。

我一直在想什么是最好的引擎。做为引擎设计者，我思量至少应该做到“从心所欲，不逾矩”吧。引擎为病毒所做，也应随着病毒的变化而变化。

杀毒引擎和主动防御是两个概念，主动防御不可能替代杀毒引擎的特征码匹配，但做为辅助是必要的。主动防御的归宿是杀毒引擎，无论病毒检测率多高，终不会高过杀毒引擎中100%的特征码匹配。

       今日立秋，又是“七月流火”的季节。

       至于什么内容的数据会导致word程序异常，可以参考naveedafzal的文章：http://www.securiteam.com/exploits/5UP0C0AJ5U.html，其原理和一些漏洞类似，非法数据导致某个dll的某个函数执行异常，EIP指针指向了某个地方，这个地方存放恶意代码。

       几个月前，国内出现了病毒“ILOVEYOU.doc”，根据其内容可基本断定为“2007最新DOC捆绑器”制作。

       病毒样本包含4部分：1Table、WordDocument、SummaryInformation、DocumentSummaryInformation。四部分基本以固定形式存放于生成器中，之后添加捆绑文件形成一个word病毒。

       其中1Table包含非法数据，引导异常；DocumentSummaryInformation中包含解压代码，释放出病毒，代码如下：

seg000:00000134 90                       nop

seg000:00000135 90                       nop

seg000:00000136 81 C7 CC+                add     edi, 1ACCh

seg000:0000013C 57                       push    edi

……

seg000:0000025Bj

seg000:00000257 80 33 92                 xor     byte ptr [ebx], 92h ; 异或解码

seg000:0000025A 43                       inc     ebx

seg000:0000025B E2 FA                    loop    loc_257

......

病毒文件和0x92异或后，分离两个PE，后者为盗取QQ秘码的病毒Trojan/PSW.GamePass.ev。

       AVP报Trojan-Dropper.MSWord.1Table.ea，特征码取1Table处；Mcafee报Exploit-MSWord.b，特征码取DocumentSummaryInformation中代码处，两者皆好。

http://www.cisrt.org/blog/read.php?329

       同一天，卡巴误报，参见：

       http://hi.baidu.com/litiejun/blog/item/11f22b7b4e29c8f50ad187ee.html

       为什么单单误报中文版？难道病毒库发布之前没有测试？不会，很有可能是这个测试库里面没有中文版的测试文件！

       一般来说，病毒库发布之前会测试各个版本的系统文件、曾误报过的文件、容易误报的文件（例如易语言，安装程序）等等，这是一项费时的工作，但是是必须的。

       国外杀软近年疯狂涌入中国，对国内病毒反应虽有提高，但仍望尘于国内杀软。卡巴略好，诺顿更糟，很多国内病毒都查不到。此次又显现出他们对中文版的态度，多少有些无视中国用户。

不单是病毒的问题，所有的商业杀软都有后门（开源的clamav等除外），如果希望自己的图纸不被国外窃取，希望能多查杀一些类似网银、证券大盗等病毒，那就用国产杀软吧。

http://www.retcvc.com/cgi-bin/attachment.cgi?forum=1&topic=1777&postno=1&name=VDebug1_1179300064&type=.rar (右键另存)

或者

http://bbs.driverdevelop.com/job.php?action=download&pid=tpc&tid=101855&aid=18301 （需要注册）

http://bbs.driverdevelop.com/job.php?action=download&pid=tpc&tid=98097&aid=17920

public:
 CFI();
 ~CFI();

private:
 BYTE Buff_H[0x400]; // 头缓冲
 BYTE Buff_E[0x400]; // 入口缓冲
 FILE *fp;
 int  File_Length; // 文件长度
 int  File_Type;  // 文件类型 1-com 2-exe 8-pe
 DWORD EP;    // 入口

private:
 int  GetFileSize(FILE *pFile);
 int  SRead(int FilePos, PBYTE pPage, int nReadLen);
 int  SWrite(int FilePos, PBYTE pPage, int nReadLen);

 DWORD Rva2Phys(IMAGE_NT_HEADERS *pPE_Header, DWORD dwAddr);
 int  InitBuff();
 bool HexstrToHex(char *str, BYTE &Val);
 int  LoadLib_GT();
 int  LoadLib_PE();
 int  LoadLib();
 FILETYPEDATA_GT *FI_GT();
 FILETYPEDATA_PE *FI_PE();
 char *FIRec(char *str);
 cli_file_t cli_filetype(const char *buf, size_t buflen, char *strInfo);
};

CFI::CFI()
{
 fp = NULL;
 File_Type = -1;
 File_Length = 0;
 EP = 0;
}

CFI::~CFI()
{

}

//------------------------------------------------------------------------------- 公用函数
// 函数功能：获取文件的大小
int CFI::GetFileSize(FILE *pFile)
{
 int Pos = ftell(pFile);
 fseek(pFile, 0, SEEK_END);
 int FileSize = ftell(pFile);
 fseek(pFile, Pos, SEEK_SET);

 return FileSize;
}

// 函数功能:读文件到制定缓冲区
int CFI::SRead(int FilePos, PBYTE pPage, int nReadLen)
{
 if (FilePos < 0 || pPage == NULL || nReadLen <= 0)
  return 0;

 fseek(fp, FilePos, SEEK_SET);
 return fread(pPage, 1, nReadLen, fp);
}

// ------------------------------------------------------------------------------- 功能函数
// 函数功能：将PE文件的Image中的线性地址转换成实际偏移
DWORD CFI::Rva2Phys(IMAGE_NT_HEADERS *pPE_Header, DWORD dwAddr)
{
 int  i;
 DWORD dwSectionOffset; // 节表偏移
 IMAGE_SECTION_HEADER *pSection_Header;

 if (pPE_Header == NULL)
  return dwAddr;

 // 范围判断
 if (dwAddr < pPE_Header->OptionalHeader.SizeOfHeaders && (int)dwAddr < File_Length)
  return dwAddr;

 // 遍历节表
 dwSectionOffset = pPE_Header->FileHeader.SizeOfOptionalHeader + 0x18; 
 for (i = 0; i < pPE_Header->FileHeader.NumberOfSections; i ++, dwSectionOffset += 0x28)
 {
  pSection_Header = (IMAGE_SECTION_HEADER*)((BYTE*)pPE_Header + dwSectionOffset);
  if ((dwAddr >= pSection_Header->VirtualAddress)  && (dwAddr < pSection_Header->VirtualAddress+pSection_Header->Misc.VirtualSize))
   return pSection_Header->PointerToRawData + dwAddr - pSection_Header->VirtualAddress ;
 }

 return dwAddr;
}

// 函数功能：初始化缓冲区
// 函数返回：0-失败；1－成功
int CFI::InitBuff()
{
 int     nPeOff;
 IMAGE_DOS_HEADER *pDos_Head;
 IMAGE_NT_HEADERS *pPE_Header;

 if (File_Type == -1)
 {
  memset(Buff_H, 0, sizeof(Buff_H)); // 头缓冲
  memset(Buff_E, 0, sizeof(Buff_E)); // 入口缓冲
 }

 File_Type = 1;
 EP = 0;
 SRead(0, Buff_H, 0x400); // 读头

 // 判断类型
 switch(*(WORD*)Buff_H)
 {
 case 'MZ':
 case 'ZM':
  File_Type = 2;
  break;
 default:
  break;
 }

 // 继续判断
 switch(File_Type)
 {
 case 1:
  {
   // 做为COM文件处理
   EP = 0;
   SRead(EP, Buff_E, 0x400);
  }
  break;
 case 2:
  {
   pDos_Head = (IMAGE_DOS_HEADER*)Buff_H;
   EP = (pDos_Head->e_cs + pDos_Head->e_cparhdr * 0x10 + pDos_Head->e_ip) & 0xfffff;
   SRead(EP, Buff_E, 0x400);

   // 是否存在PE
   nPeOff = *(DWORD*)(Buff_H+0x3c);
   if (nPeOff != 0 && File_Length > nPeOff) 
   {
    SRead(nPeOff, Buff_E, 8);
    if (*(WORD*)Buff_E == 'EP')
    {
     SRead(nPeOff, Buff_H, 0x400);
     File_Type = 8;

     // 读PE入口代码到Buff_E
     pPE_Header = (IMAGE_NT_HEADERS*)Buff_H;
     EP = Rva2Phys(pPE_Header, pPE_Header->OptionalHeader.AddressOfEntryPoint);
     SRead(EP, Buff_E, 0x400);
    }
   }
  }
  break;
 default:
  SRead(0, Buff_E, 0x400);
  break;
 }

 return 1;
}

// 函数功能：16进制字符串转化为数字
// 函数返回：0不是16进制数，1是十六进制数
bool CFI::HexstrToHex(char *str, BYTE &Val)
{
 int  nLen;
 int  i;
 int  pow;
 BYTE s;
 char ch;   
 char *p;

 nLen = 2;
 p = str + nLen;
 s = 0;
 pow = 1;
 for(i = nLen; i > 0; i --)
 {
  ch = *(--p);

  if ((ch >= 'a') && (ch <= 'f'))
   ch = ch - 'a' + 10;
  else if ((ch >= 'A') && (ch <= 'F'))
   ch = ch -  'A' + 10;
  else if ((ch >= '0') && (ch <= '9'))
   ch = ch - '0';
  else
   return false;

  s += ch * pow;
  pow *= 16;
 }

 Val = s;
 return 1;
}

// 函数功能：加载文件类型数据
// 函数返回：0-失败；1－成功
int CFI::LoadLib_GT()
{
 int  i, j;
 int  nRecCount;
 int  nStrLen;
 char *p;
 FILETYPEDATA_GT *pRecGT;

 // 加载GT库
 pRecGT = FileTypeRec_GT;
 nRecCount = sizeof(FileTypeRec_GT)/sizeof(FILETYPEDATA_GT);
 for (i = 0; i < nRecCount; i ++, pRecGT ++)
 {
  memset(pRecGT->RecData, 0, sizeof(pRecGT->RecData));
  nStrLen = strlen(pRecGT->strData);
  pRecGT->nRecLen = nStrLen/2;
  p = pRecGT->strData;
  for (j = 0; j < pRecGT->nRecLen; j ++)
  {
   if (!HexstrToHex(p, pRecGT->RecData[j]))
    break;
   p += 2;
  }
 }
 return 1;
}

// 函数功能：加载文件类型数据
// 函数返回：0-失败；1－成功
int CFI::LoadLib_PE()
{
 int  i, j;
 int  nRecCount;
 int  nStrLen;
 char *p;
 FILETYPEDATA_PE *pRecPE;

 // 加载PE库
 pRecPE = FileTypeRec_PE;
 nRecCount = sizeof(FileTypeRec_PE)/sizeof(FILETYPEDATA_PE);
 for (i = 0; i < nRecCount; i ++, pRecPE ++)
 {
  // Pos
  memset(pRecPE->PosData, 0, sizeof(pRecPE->PosData));
  nStrLen = strlen(pRecPE->Pos);
  pRecPE->nPosLen = nStrLen/2;
  p = pRecPE->Pos;
  for (j = 0; j < pRecPE->nPosLen; j ++)
  {
   if (!HexstrToHex(p, pRecPE->PosData[j]))
    break;
   p += 2;
  }

  // Fea
  memset(pRecPE->FeaData, 0, sizeof(pRecPE->FeaData));
  nStrLen = strlen(pRecPE->Fea);
  pRecPE->nFeaLen = nStrLen/2;
  p = pRecPE->Fea;
  for (j = 0; j < pRecPE->nFeaLen; j ++)
  {
   if (!HexstrToHex(p, pRecPE->FeaData[j]))
    break;
   p += 2;
  }
 }
 return 1;
}

// 函数功能：加载文件类型数据
// 函数返回：0-失败；1－成功
int CFI::LoadLib()
{
 LoadLib_GT();
 LoadLib_PE();
 return 1;
}

// 分析文件类型GT
FILETYPEDATA_GT *CFI::FI_GT()
{
 int  i, j, s;
 int  nRecCount;
 BYTE *p;
 FILETYPEDATA_GT *pRecGT;

 // GT库
 pRecGT = FileTypeRec_GT;
 nRecCount = sizeof(FileTypeRec_GT)/sizeof(FILETYPEDATA_GT);
 for (i = 0; i < nRecCount; i ++, pRecGT ++)
 {
  s = 0;
  p = pRecGT->RecData;
  for (j = 0; j < pRecGT->nRecLen; j ++, p ++)
  {
   if (*p == 0)
    continue;
   s = s + (*p ^ Buff_E[j]);
   if (s != 0)
    break;
  }
  if (s == 0)
   return pRecGT;
 }

 return NULL;
}

// 分析文件类型PE
FILETYPEDATA_PE *CFI::FI_PE()
{
 int  i, j;
 int  nRecCount;
 BYTE *p;
 FILETYPEDATA_PE *pRecPE;

 // PE库
 pRecPE = FileTypeRec_PE;
 nRecCount = sizeof(FileTypeRec_PE)/sizeof(FILETYPEDATA_PE);
 for (i = 0; i < nRecCount; i ++, pRecPE ++)
 {
  p = pRecPE->FeaData;
  if (pRecPE->IsOrdered)
  {
   for (j = 0; j < pRecPE->nFeaLen; j ++, p ++)
   {
    if (*p != Buff_E[j])
     break;
   }
   if (j == pRecPE->nFeaLen)
    return pRecPE;
  }
  else
  {
   for (j = 0; j < pRecPE->nFeaLen; j ++, p ++)
   {
    if (*p != Buff_E[pRecPE->PosData[j]-1])
     break;
   }
   if (j == pRecPE->nFeaLen)
    return pRecPE;
  }
 }

 return NULL;
}

// 分析文件类型
char *CFI::FIRec(char *str)
{
 FILETYPEDATA_GT *pRecGT;
 FILETYPEDATA_PE *pRecPE;

 // PE
 if ((pRecPE=FI_PE()) != NULL)
 {
  strcpy(str, pRecPE->Info);
  return str;
 }

 // GT
 if ((pRecGT=FI_GT()) != NULL)
 {
  strcpy(str, pRecGT->strName);
  strcat(str, "   ");
  strcat(str, pRecGT->strType);
  return str;
 }

 return NULL;
}

// 函数功能：分析文件类型
cli_file_t CFI::cli_filetype(const char *buf, size_t buflen, char *strInfo)
{
 int i, ascii = 1, len;

 for(i = 0; cli_magic[i].magic; i++) 
 {
  if(buflen >= cli_magic[i].offset+cli_magic[i].length) 
  {
   if(memcmp(buf+cli_magic[i].offset, cli_magic[i].magic, cli_magic[i].length) == 0) 
   {
    strcpy(strInfo, cli_magic[i].descr);
    return cli_magic[i].type;
   }
  }
 }

 buflen < 25 ? (len = buflen) : (len = 25);
 for(i = 0; i < len; i++)
 {
  if(!internat[buf[i] & 0xff]) 
  {
   ascii = 0;
   break;
  }
 }

 if (ascii)
  strcpy(strInfo, "Text file.");
 else
  strcpy(strInfo, "COM file or Others.");
 return ascii ? CL_TYPE_UNKNOWN_TEXT : CL_TYPE_UNKNOWN_DATA;
}

// 分析文件加壳等类型
int CFI::FI(char *strFileName, char *strInfo)
{
 // 打开文件
 if ((fp = fopen(strFileName, "rb")) == NULL)
 {
  strcpy(strInfo, "Open file failed.");
  return false;
 }

 // 读文件大小
 if ((File_Length = GetFileSize(fp)) == 0)
 {
  strcpy(strInfo, "Size of file is 0.\n");
  return false;
 }

 // 初始化缓冲区
 if (!InitBuff())
 {
  strcpy(strInfo, "Isn't exe file.\n");
  return false;
 }

 // 加载类型库
 if (!LoadLib())
 {
  strcpy(strInfo, "Load filetype lib failed.\n");
  return false;
 }

 // 判断类型
 if (!FIRec(strInfo))
 {
  if (File_Type == 2)
   strcpy(strInfo, "DOS execute file!\n");
  else if (File_Type == 8)
   strcpy(strInfo, "PE file!\n");
  else 
  {
   SRead(0, Buff_H, sizeof(Buff_H));
   cli_filetype((char*)Buff_H, sizeof(Buff_H), strInfo);
  }
 }
 return true;
}

void main(int avgc, char **argv)
{
 char strFileInfo[0x200];
 CFI  aFi;

 // 初始化
 printf("FileInfo v1.0 (c) 2006.10.23 by wangwei.\n");
 printf("My bolg: http://hi.baidu.com/avengine\n\n");
 memset(strFileInfo, 0, sizeof(strFileInfo));
 if (avgc != 2)
 {
  printf("Fi [FILE]\n");
  return;
 }

 // 判断类型
 aFi.FI(argv[1], strFileInfo);
 printf("%s\n", strFileInfo);
}