2014年08月04日 这博客已经一年多没更新没管过了……算是废了吧。主要是人懒,怨不得别人。 WordPress就是一坑,插件太多,搞顺畅太麻烦而且也太庞大了。所以觉得搞个轻量级的个人博客系统,后续博客转战blog.wangfu.info,功能随想着随加。

Delphi在Vasta/win 7下通过UAC控制

2011年4月19日  2,690 views 没有评论
在Windows编程时,为了兼容Win7与XP,许多需要底层权限的程序需要通过UAC验证,这是微软出的一个很恶心的东西……还不如Ubuntu那种Root机制呢……但是有困难我们就要克服~
现在有一种方式可以变相的绕过UAC控制。其实UAC控制有一点很弱智的是,当你的程序名字中包含Installation、Setup等词时,UAC认为你是安装程序,会默认进行UAC提示,提示用户给此程序提高权限。这对于安装包可以简单解决,但是如果我们的主程序也需要高权限的话,我们需要一个manifest文件来告诉UAC:我需要一个较高的权限,UAC也会提示用户提权。具体操作如下,但是此方法有个不能解决的问题是UAC会提示次软件未经微软认证,执行可能会影响安全。解决方法只有一个,那就是购买微软的软件认证……坑爹啊!

1.建立 res 文件

建立一个文本文件,名字可以自己起,我这里叫:UAC.manifest,内容:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
<security>
<requestedPrivileges>
<!--这是主要的一句,申请Admin权限,等同于右键管理员打开。-->
<requestedExecutionLevel level="requireAdministrator"/>
</requestedPrivileges>
</security>
</trustInfo>
</assembly>

建立文本文件,名为 UAC.rc,内容:

1 24 UAC.manifest

编译成 uac.res 文件,运行:brcc32 uac.rc -fouac.res

2.在代码中引入

打开项目文件,加入

{$R uac.res}

3.编译程序

这时程序就支持 VISTA 和WIN7的UAC了,在运行的时候,会弹出 WINDOWS 的提示框,询问用户是否允许以管理员身份运行。

分类: 心得笔记 标签: ,

MD5.pas – 一个Delphi下的MD5算法的实现

2011年4月19日  4,262 views 3 条评论

MD5是现在常用的加密算法,可用在程序密码加密上,在注册表或者文件中保存用户密码的MD5值,可以检验用户输入密码的正确性。或者为了程序的安全性,不被别人修改文件,可以对自己的文件进行MD5验证。总之,MD5加密算法是一种十分有用的算法。

通常,我们不关心MD5算法实现的具体过程……我们要的是可以执行的函数,为了节省开发周期,你懂得~下文列出了一个可以直接使用的MD5算法文件的Delphi版本,以后有时间会再转载一些其他语言的版本。

代码如下:

unit MD5;
interface
uses
    SysUtils;
const
    MD5Version         = 102;
    CopyRight : String = ' MD5 Message-Digest (c) 97-98 F. Piette V1.02 ';

{$Q-}
{$R-}

type
    TMD5Context = record
        State: array[0..3] of LongInt;
        Count: array[0..1] of LongInt;
        case Integer of
        0: (BufChar: array[0..63] of Byte);
        1: (BufLong: array[0..15] of LongInt);
    end;
    TMD5Digest = array[0..15] of Char;

procedure MD5Init(var MD5Context: TMD5Context);
procedure MD5Update(var MD5Context: TMD5Context;
                    const Data;
                    Len: Integer);
procedure MD5Transform(var Buf: array of LongInt;
                       const Data: array of LongInt);
procedure MD5UpdateBuffer(var MD5Context: TMD5Context;
                          Buffer: Pointer;
                          BufSize: Integer);
procedure MD5Final(var Digest: TMD5Digest; var MD5Context: TMD5Context);

function GetMD5(Buffer: Pointer; BufSize: Integer): string;
function StrMD5(Buffer : String): string;

implementation

const
    MaxBufSize = 16384;

type
    PMD5Buffer = ^TMD5Buffer;
    TMD5Buffer = array[0..(MaxBufSize - 1)] of Char;


{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
{ MD5 initialization. Begins an MD5 operation, writing a new context.         }
procedure MD5Init(var MD5Context: TMD5Context);
begin
    FillChar(MD5Context, SizeOf(TMD5Context), #0);
    with MD5Context do begin
        { Load magic initialization constants. }
        State[0] := LongInt($67452301);
        State[1] := LongInt($EFCDAB89);
        State[2] := LongInt($98BADCFE);
        State[3] := LongInt($10325476);
    end
end;


{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
{ MD5 block update operation. Continues an MD5 message-digest operation,      }
{ processing another message block, and updating the context.                 }
procedure MD5Update(
    var MD5Context: TMD5Context;            { Context                         }
    const Data;                             { Input block                     }
    Len: Integer);                          { Length of input block           }
type
    TByteArray = array[0..0] of Byte;
var
    Index: Word;
    T: LongInt;
begin
    with MD5Context do begin
        T := Count[0];
        Inc(Count[0], LongInt(Len) shl 3);
        if Count[0] < T then
            Inc(Count[1]);
        Inc(Count[1], Len shr 29);
        T := (T shr 3) and $3F;
        Index := 0;
        if T <> 0 then begin
            Index := T;
            T := 64 - T;
            if Len < T then begin
                Move(Data, BufChar[Index], Len);
                Exit;
            end;
            Move(Data, BufChar[Index], T);
            MD5Transform(State, BufLong);
            Dec(Len, T);
            Index := T; { Wolfgang Klein, 05/06/99 }
        end;
        while Len >= 64 do begin
            Move(TByteArray(Data)[Index], BufChar, 64);
            MD5Transform(State, BufLong);
            Inc(Index, 64);
            Dec(Len, 64);
        end;
        Move(TByteArray(Data)[Index], BufChar, Len);
    end
end;


{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
{ MD5 finalization. Ends an MD5 message-digest operation, writing the message }
{ digest and zeroizing the context.                                           }
procedure MD5Final(var Digest: TMD5Digest; var MD5Context: TMD5Context);
var
    Cnt : Word;
    P   : Byte;
begin
    with MD5Context do begin
        Cnt := (Count[0] shr 3) and $3F;
        P := Cnt;
        BufChar[P] := $80;
        Inc(P);
        Cnt := 64 - 1 - Cnt;
        if Cnt < 8 then begin
            FillChar(BufChar[P], Cnt, #0);
            MD5Transform(State, BufLong);
            FillChar(BufChar, 56, #0);
        end
        else
            FillChar(BufChar[P], Cnt - 8, #0);
        BufLong[14] := Count[0];
        BufLong[15] := Count[1];
        MD5Transform(State, BufLong);
        Move(State, Digest, 16)
    end;
    FillChar(MD5Context, SizeOf(TMD5Context), #0)
end;


{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
{ MD5 basic transformation. Transforms state based on block.                  }
procedure MD5Transform(
    var Buf: array of LongInt;
    const Data: array of LongInt);
var
    A, B, C, D: LongInt;

    procedure Round1(var W: LongInt; X, Y, Z, Data: LongInt; S: Byte);
    begin
        Inc(W, (Z xor (X and (Y xor Z))) + Data);
        W := (W shl S) or (W shr (32 - S));
        Inc(W, X)
    end;

    procedure Round2(var W: LongInt; X, Y, Z, Data: LongInt; S: Byte);
    begin
        Inc(W, (Y xor (Z and (X xor Y))) + Data);
        W := (W shl S) or (W shr (32 - S));
        Inc(W, X)
    end;

    procedure Round3(var W: LongInt; X, Y, Z, Data: LongInt; S: Byte);
    begin
        Inc(W, (X xor Y xor Z) + Data);
        W := (W shl S) or (W shr (32 - S));
        Inc(W, X)
    end;

    procedure Round4(var W: LongInt; X, Y, Z, Data: LongInt; S: Byte);
    begin
        Inc(W, (Y xor (X or not Z)) + Data);
        W := (W shl S) or (W shr (32 - S));
        Inc(W, X)
    end;
begin
    A := Buf[0];
    B := Buf[1];
    C := Buf[2];
    D := Buf[3];

    Round1(A, B, C, D, Data[ 0] + LongInt($d76aa478), 7);
    Round1(D, A, B, C, Data[ 1] + LongInt($e8c7b756), 12);
    Round1(C, D, A, B, Data[ 2] + LongInt($242070db), 17);
    Round1(B, C, D, A, Data[ 3] + LongInt($c1bdceee), 22);
    Round1(A, B, C, D, Data[ 4] + LongInt($f57c0faf), 7);
    Round1(D, A, B, C, Data[ 5] + LongInt($4787c62a), 12);
    Round1(C, D, A, B, Data[ 6] + LongInt($a8304613), 17);
    Round1(B, C, D, A, Data[ 7] + LongInt($fd469501), 22);
    Round1(A, B, C, D, Data[ 8] + LongInt($698098d8), 7);
    Round1(D, A, B, C, Data[ 9] + LongInt($8b44f7af), 12);
    Round1(C, D, A, B, Data[10] + LongInt($ffff5bb1), 17);
    Round1(B, C, D, A, Data[11] + LongInt($895cd7be), 22);
    Round1(A, B, C, D, Data[12] + LongInt($6b901122), 7);
    Round1(D, A, B, C, Data[13] + LongInt($fd987193), 12);
    Round1(C, D, A, B, Data[14] + LongInt($a679438e), 17);
    Round1(B, C, D, A, Data[15] + LongInt($49b40821), 22);

    Round2(A, B, C, D, Data[ 1] + LongInt($f61e2562), 5);
    Round2(D, A, B, C, Data[ 6] + LongInt($c040b340), 9);
    Round2(C, D, A, B, Data[11] + LongInt($265e5a51), 14);
    Round2(B, C, D, A, Data[ 0] + LongInt($e9b6c7aa), 20);
    Round2(A, B, C, D, Data[ 5] + LongInt($d62f105d), 5);
    Round2(D, A, B, C, Data[10] + LongInt($02441453), 9);
    Round2(C, D, A, B, Data[15] + LongInt($d8a1e681), 14);
    Round2(B, C, D, A, Data[ 4] + LongInt($e7d3fbc8), 20);
    Round2(A, B, C, D, Data[ 9] + LongInt($21e1cde6), 5);
    Round2(D, A, B, C, Data[14] + LongInt($c33707d6), 9);
    Round2(C, D, A, B, Data[ 3] + LongInt($f4d50d87), 14);
    Round2(B, C, D, A, Data[ 8] + LongInt($455a14ed), 20);
    Round2(A, B, C, D, Data[13] + LongInt($a9e3e905), 5);
    Round2(D, A, B, C, Data[ 2] + LongInt($fcefa3f8), 9);
    Round2(C, D, A, B, Data[ 7] + LongInt($676f02d9), 14);
    Round2(B, C, D, A, Data[12] + LongInt($8d2a4c8a), 20);

    Round3(A, B, C, D, Data[ 5] + LongInt($fffa3942), 4);
    Round3(D, A, B, C, Data[ 8] + LongInt($8771f681), 11);
    Round3(C, D, A, B, Data[11] + LongInt($6d9d6122), 16);
    Round3(B, C, D, A, Data[14] + LongInt($fde5380c), 23);
    Round3(A, B, C, D, Data[ 1] + LongInt($a4beea44), 4);
    Round3(D, A, B, C, Data[ 4] + LongInt($4bdecfa9), 11);
    Round3(C, D, A, B, Data[ 7] + LongInt($f6bb4b60), 16);
    Round3(B, C, D, A, Data[10] + LongInt($bebfbc70), 23);
    Round3(A, B, C, D, Data[13] + LongInt($289b7ec6), 4);
    Round3(D, A, B, C, Data[ 0] + LongInt($eaa127fa), 11);
    Round3(C, D, A, B, Data[ 3] + LongInt($d4ef3085), 16);
    Round3(B, C, D, A, Data[ 6] + LongInt($04881d05), 23);
    Round3(A, B, C, D, Data[ 9] + LongInt($d9d4d039), 4);
    Round3(D, A, B, C, Data[12] + LongInt($e6db99e5), 11);
    Round3(C, D, A, B, Data[15] + LongInt($1fa27cf8), 16);
    Round3(B, C, D, A, Data[ 2] + LongInt($c4ac5665), 23);

    Round4(A, B, C, D, Data[ 0] + LongInt($f4292244), 6);
    Round4(D, A, B, C, Data[ 7] + LongInt($432aff97), 10);
    Round4(C, D, A, B, Data[14] + LongInt($ab9423a7), 15);
    Round4(B, C, D, A, Data[ 5] + LongInt($fc93a039), 21);
    Round4(A, B, C, D, Data[12] + LongInt($655b59c3), 6);
    Round4(D, A, B, C, Data[ 3] + LongInt($8f0ccc92), 10);
    Round4(C, D, A, B, Data[10] + LongInt($ffeff47d), 15);
    Round4(B, C, D, A, Data[ 1] + LongInt($85845dd1), 21);
    Round4(A, B, C, D, Data[ 8] + LongInt($6fa87e4f), 6);
    Round4(D, A, B, C, Data[15] + LongInt($fe2ce6e0), 10);
    Round4(C, D, A, B, Data[ 6] + LongInt($a3014314), 15);
    Round4(B, C, D, A, Data[13] + LongInt($4e0811a1), 21);
    Round4(A, B, C, D, Data[ 4] + LongInt($f7537e82), 6);
    Round4(D, A, B, C, Data[11] + LongInt($bd3af235), 10);
    Round4(C, D, A, B, Data[ 2] + LongInt($2ad7d2bb), 15);
    Round4(B, C, D, A, Data[ 9] + LongInt($eb86d391), 21);

    Inc(Buf[0], A);
    Inc(Buf[1], B);
    Inc(Buf[2], C);
    Inc(Buf[3], D);
end;


{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
procedure MD5UpdateBuffer(
    var MD5Context: TMD5Context;
    Buffer: Pointer;
    BufSize: Integer);
var
    BufTmp : PMD5Buffer;
    BufPtr : PChar;
    Bytes : Word;
begin
    New(BufTmp);
    BufPtr := Buffer;
    try
        repeat
            if BufSize > MaxBufSize then
                Bytes := MaxBufSize
            else
                Bytes := BufSize;
            Move(BufPtr^, BufTmp^, Bytes);
            Inc(BufPtr, Bytes);
            Dec(BufSize, Bytes);
            if Bytes > 0 then
                MD5Update(MD5Context, BufTmp^, Bytes);
        until Bytes < MaxBufSize;
    finally
        Dispose(BufTmp);
    end;
end;


{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
function GetMD5(Buffer: Pointer; BufSize: Integer): string;
var
    I          : Integer;
    MD5Digest : TMD5Digest;
    MD5Context : TMD5Context;
begin
    for I := 0 to 15 do
        Byte(MD5Digest[I]) := I + 1;
    MD5Init(MD5Context);
    MD5UpdateBuffer(MD5Context, Buffer, BufSize);
    MD5Final(MD5Digest, MD5Context);
    Result := '';
    for I := 0 to 15 do
        Result := Result + IntToHex(Byte(MD5Digest[I]), 2);
end;


{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
function StrMD5(Buffer : String): string;
begin
    Result := GetMD5(@Buffer[1], Length(Buffer));
end;


{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}

end.
  
分类: 网络资源 标签:

C/C++中printf函数的格式控制

2011年4月19日  3,849 views 没有评论

printf的格式控制的完整格式:
%  -  0  m.n  l或h  格式字符
下面对组成格式说明的各项加以说明:
①%:表示格式说明的起始符号,不可缺少。
②-:有-表示左对齐输出,如省略表示右对齐输出。
③0:有0表示指定空位填0,如省略表示指定空位不填。
④m.n:m指域宽,即对应的输出项在输出设备上所占的字符数。N指精度。用于说明输出的实型数的小数位数。为指定n时,隐含的精度为n=6位。
⑤l或h:l对整型指long型,对实型指double型。h用于将整型的格式字符修正为short型。

---------------------------------------
格式字符
格式字符用以指定输出项的数据类型和输出格式。
①d格式:用来输出十进制整数。有以下几种用法:
%d:按整型数据的实际长度输出。
%md:m为指定的输出字段的宽度。如果数据的位数小于m,则左端补以空格,若大于m,则按实际位数输出。
%ld:输出长整型数据。
②o格式:以无符号八进制形式输出整数。对长整型可以用”%lo”格式输出。同样也可以指定字段宽度用“%mo”格式输出。
例:
main()
{ int a = -1;
printf(“%d, %o”, a, a);
}
运行结果:-1,177777

阅读全文…

分类: 网络资源 标签: ,

C/C++中随机数生成的几个函数

2011年4月19日  5,060 views 没有评论

随机数生成

要产生一个随机数,必须得指定一个随机数种子。指定随机数种子可以通过以下两个函数来实现—–randomize()srand().

randomize():它的功能是初始化随机数发生器。在c++ builder中函数声明如下:
extern PACKAGE void __fastcall Randomize(void)
其英文描述如下:
Randomize initializes the built-in random number generator with a random value (obtained from the system clock). The random number generator should be initialized by making a call to Randomize, or by assigning a value to RandSeed.
可以看出,randomize()函数是用系统的时间作为随机数种子,初始化随机数发生器的。

在C++中不能使用randomizerandomrandom函数不是ANSI C标准,不能在gcc,vc等编译器下编译通过。 可改用C++下的rand函数来实现。

srand():它的功能也是初始化随机数发生器。在c++ builder中函数声明如下:
void srand(unsigned seed)
其英文描述:
Initializes random number generator.
The random number generator is reinitialized by calling srand with an argument value of 1. It can be set to a new starting point by calling srand with a given seed number.
可以看出:srand()是通过参数seed来指定随机数种子的。

指定了随机数种子,我们就可以调用函数 rand() random()来产生随机数了。调用它可以返回一个随机数。

rand()函数其定义如下
int rand():调用它将返回一个0–32767之间的一个int 型数值。

random()函数其定义如下:
int random(int num):调用它可以返回一个 0—(num-1)之间的一个int 型数值。

若想返回一个从[a,b)之间的数,可以通过一个通用的公式:
(rand()%(b-a))+a  返回的数值包含a,包含b。若 a=0,就可以返回一个 0–b之间的数值。

在实际的应用中,要注意的是:若初始化随机数种子一样,则它产生的随机数是一样的。反之,若每次想产生不同的随机数,则必须使每次的随机数种子不一样才行。

 

分类: 心得笔记 标签:

“我思维比较,喜欢看个黄书” ”我在春天花花幼儿园上过学“ -郭德纲的相声很Happy啊

2011年4月19日  2,284 views 没有评论
分类: 网络资源, 视频 标签:

一些常用的算法与数据结构

2011年4月19日  2,194 views 没有评论

哈希函数

哈希法,又称散列法、杂凑法、关键字地址计算法。这种方法的中心思想是,首先在元素的关键字k和存储位置p之间建立一个对应关系f,使得p=f(k),f称为哈希函数。
创建哈希表时,把关键字为k的元素直接存入地址为f(k)的单元,以后当查找关键字为k的元素时,再利用哈希函数计算出该元素所存储的位置p=(k),从而达到按关键字直接存取元素的目的。

哈希函数的构造方法:
1、数字分析法,如果关键字中有分布较为均匀的部分,则可以使用这几位为哈希地址。例如关键字是4位整数d1d2d3d4,其中d2和d4取值均匀,那么哈希函数可以设为h(key)=h(d1d2d3d4)=d2d4。
2、平方取中发,如果不能确定关键字中那几位分布较为均匀,那么可以先求出关键字的平方值,然后按需要取平方值的中间几位作为哈希地址。这是因为平方后中间几位和关键字中每一位都相关,故不同关键字会以较高的概率产生不同的哈希地址。
3、分段叠加法,这种方法是将关键字按照哈希地址表的位数进行分割,分成几个部分,然后将每一部分相加,舍弃最高进位后得到哈希地址。具体方法有折叠法和移位法。移位法是将每一部分按照低位对齐的方式相加,折叠法是将关键字之字形排列后相加。
4、除余数法,哈希表长为m,那么取小于等于m的最大质数p,那么哈希函数为h(k)=k%p,其中%是模p取余运算。如果m与p较小,那么出现冲突的几率会比较大,这时可以取较大的m和p,比如大于m的最小质数,如果还是不行,那么重复上步。
5、伪随机数法,采用一个伪随机数函数作为哈希函数,即h(key)=random(key)。实际应用中考虑实际情况选择不同的random函数。考虑使用方法时,要考虑的因素有5个,计算哈希函数所需要的时间、关键字的长度、哈希表大小、关键字分布情况、jiluchazhaopinl

哈希函数处理冲突:创建哈希表和查找哈希表都会遇到冲突,两种情况下解决冲突的方法应该是一致的。
(1) 开放地址法,这种方法又称再散列法,其基本思想是:当关键字key的哈希地址p=H(key)出现冲突时,以p为基础,产生另一个哈希地址p1,如果仍然冲突,再以p为基础,产生另一个哈希地址p2,……,直到找到一个不冲突的哈希地址pi,将相应元素存入其中。
通用函数形式:Hi=(H(key)+di)%m(i=1,2,……,n)
H(key)是哈希函数,m为表长,di称为增量序列。增量序列的取值方式不同,相应的再散列方式也不同。

  • 线性探测再散列 di=1,2,3,……,m-1
  • 二次探测再散列 di=1^2,-1^2,2^2,-2^2,…,k^2,-k^2  (k<m/2) 方法特点:冲突发生时,在表的左右进行跳跃式探测,比较灵活。
  • 伪随机探测再散列 di=伪随机数序列

(2)再哈希法

阅读全文…

分类: 心得笔记 标签: , , ,