100分求反汇编CoCreateGUID的源代码

[LongLong_2008]

谁懂反汇编？知道CoCreateGUID微软是用什么算法吗？有源代码最好

[cnzdgs]

只要你懂汇编，跟踪进去看一下就明白了。

[czbever]

跟踪进去，能不能翻译成C语言让我看看呢？

[killbug2004]

IDA后F5试试吧,我是IDA+symbols后看的伪代码

HRESULT __stdcall CoCreateGuid(GUID *pguid)
{
  HRESULT result; // eax@3

  if ( !pguid || ValidateInPointers() && IsBadWritePtr(pguid, 0x10u) )
  {
    result = -2147024809;
  }
  else
  {
    result = UuidCreate(pguid);
    if ( result != 1824 && result )
    {
      if ( result > 0 )
        result = (_WORD)result | 0x80070000;
    }
    else
    {
      result = 0;
    }
  }
  return result;
}

[czbever]

UuidCreate(pguid);
这个又要反汇编了吧

[killbug2004]

RPC_STATUS __stdcall UuidCreate(UUID *Uuid)
{
  RPC_STATUS result; // eax@1
  UUID *v2; // esi@1

  v2 = Uuid;
  result = GenerateRandomNumber((unsigned __int8 *)Uuid, 16);
  if ( !result )
  {
    v2->Data3 = v2->Data3 & 0xFFF | 0x4000;
    v2->Data4[0] = v2->Data4[0] & 0x3F | 0x80;
    result = 0;
  }
  return result;
}

--------------

signed int __stdcall GenerateRandomNumber(unsigned __int8 *a1, int a2)
{
  unsigned __int8 *v2; // edi@1
  unsigned int v4; // [sp+8h] [bp-10Ch]@1
  int v5; // [sp+Ch] [bp-108h]@1
  char v6; // [sp+10h] [bp-104h]@4

  v4 = 0;
  v2 = a1;
  rc4_safe_select(g_rc4SafeCtx, &v5, &v4);
  if ( v4 < 0x7A120 )
    goto LABEL_2;
  if ( (unsigned __int8)SystemFunction036(&v6, 256) )
  {
    rc4_safe_key(g_rc4SafeCtx, v5, 256, &v6);
LABEL_2:
    rc4_safe(g_rc4SafeCtx, v5, a2, v2);
    return 0;
  }
  return 14;
}

RPC_STATUS __stdcall UuidCreate(UUID *Uuid){
	rc4_safe_select(x,x,x);
	NewGenRandom(x,x,x,x);
	rc4_safe_key(x,x,x,x);
}

__stdcall NewGenRandom(x,x,x,x)
{
	NewGenRandomEx(x,x,x);
}

__stdcall NewGenRandomEx(x,x,x){
	InitRand(x,x);
	InitializeRNG(x);
	GenRandom(x,x,x);
}

__stdcall InitRand(x,x){
	InitCircularHash(x,x,x,x);
	ReadSeed(x,x);
}

int __stdcall ReadSeed(LPBYTE lpData,DWORD cbData){
	AccessSeed(x,x);
	RegQueryValueEx("SOFTWARE\Microsoft\Cryptography\RNG\Seed");	
}

int __stdcall AccessSeed(REGSAM samDesired,DWORD dwDisposition){
	RegCreateKeyEx("SOFTWARE\Microsoft\Cryptography\RNG\Seed");
}

__stdcall InitializeRNG(x){
	rc4_safe_startup(x);
	InterlockedCompareExchangePointerWin95(x,x,x);
}

__stdcall InterlockedCompareExchangePointerWin95(x,x,x){
	InterlockedCompareExchange();
}


__stdcall GenRandom(x,x,x){
	RandomFillBuffer(x,x);
	
}

__stdcall RandomFillBuffer(x,x){
	UpdateCircularHash(x,x,x);
	rc4_safe_select(x,x,x);
	GetCircularHashValue(x,x,x);
	GatherRandomKey(x,x,x,x);
	rc4_safe_key(x,x,x,x);
	rc4_safe(x,x,x,x);
}


__stdcall UpdateCircularHash(x,x,x){
	MD4Init(x);
	MD4Update(x,x,x);
	MD4Final(x);

}

int __stdcall GatherRandomKey(LPVOID lpInBuffer,DWORD nInBufferSize,LPVOID lpOutBuffer,LPDWORD lpBytesReturned){
	GatherRandomKeyFastUserMode(x,x,x,x);
}

int __stdcall GatherRandomKeyFastUserMode(LPVOID lpInBuffer,DWORD nInBufferSize,LPVOID lpOutBuffer,LPDWORD lpBytesReturned){
	IsRNGWinNT();
	NtOpenFile("\\Device\\KsecDD");
	InterlockedCompareExchangePointerWin95(x,x,x);	
}

楼主去找泄露的源码看看有没有

[LongLong_2008]

up 我也是出这个错

[LongLong_2008]

// GUID.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<stdio.h>

#include"GUID.h"
#include< Rpc.h>


BOOLEAN RtlGenRandom( __out  PVOID RandomBuffer, __in   ULONG RandomBufferLength);
RPCRTAPI RPC_STATUS RPC_ENTRY UuidCreate (OUT UUID __RPC_FAR * Uuid);
RPC_STATUS GenerateRandomNumber(BYTE* pbData, DWORD cbData);
void rc4_safe_select(pRC4_CONTEXT pRC4Ctx, DWORD* pInstNum, DWORD* pAccumulator);
void rc4_revert(PRC4_INSTANCE_STATE pRC4State, DWORD cbData, BYTE* pbData);
void rc4_safe(pRC4_CONTEXT pRC4Ctx, DWORD InstNum, DWORD cbData, BYTE* pbData);

void rc4(PRC4_INSTANCE_STATE pRC4State, DWORD cbData, BYTE* pbData);
void rc4_key(PRC4_INSTANCE_STATE pRC4State, DWORD cbData, BYTE* pbData);
void rc4_safe_key(pRC4_CONTEXT pRC4Ctx, DWORD InstNum, DWORD cbData, BYTE* pbData);


RPCRTAPI RPC_STATUS RPC_ENTRY UuidCreate (OUT UUID __RPC_FAR * Uuid)
{
      RPC_STATUS ret;
      ret = GenerateRandomNumber((BYTE*)Uuid, sizeof(UUID));
      if (ret == RPC_S_OK)
	  {
            // Устанавливаем версию 
            Uuid->Data3 = (Uuid->Data3 & 0x0fff) | 0x4000;
            // Клянёмся в верности формату RFC4122
            Uuid->Data4[0] = (Uuid->Data4[0] & 0x3F) | 0x80;
      }
      return ret;

}

void rc4_safe_key(pRC4_CONTEXT pRC4Ctx, DWORD InstNum, DWORD cbData, BYTE* pbData)

{

      EnterCriticalSection(&pRC4Ctx->Rc4Ins[InstNum]->CS);

      //RC4 Key Scheduling Algorithm (KSA)
      rc4_key(&pRC4Ctx->Rc4Ins[InstNum]->State, cbData, pbData);
      LeaveCriticalSection(&pRC4Ctx->Rc4Ins[InstNum]->CS);
}



RPC_STATUS GenerateRandomNumber(BYTE* pbData, DWORD cbData) 

{
      // Суммарное кол-во байт выхода текущего экземпляра RC4
      // с момента его инициализации
      DWORD Accumulator = 0;  
      // Номер текущего экземпляра RC4
      DWORD InstNum;
      // Буфер для ключа RC4, если потребуется инициализация
      PVOID RandomKey;
      rc4_safe_select(&g_rc4SafeCtx, &InstNum, &Accumulator);
      if (Accumulator >= 500000)
      {
            //Инициализация
            //Генерация псевдо-случайного ключа для RC4
            if (!SystemFunction036(RandomKey, 256))
                 return RPC_S_OUT_OF_MEMORY;
            // Инициализация экземпляра RC4
            rc4_safe_key(&g_rc4SafeCtx, InstNum, 256, (BYTE*)RandomKey);
      }
      // Генерация значения UUID с помощью алгоритма RC4
      rc4_safe(&g_rc4SafeCtx, InstNum, cbData, pbData);
      return RPC_S_OK;

}


void rc4_safe_select(pRC4_CONTEXT pRC4Ctx, DWORD* pInstNum, DWORD* pAccumulator)

{
      g_rc4TotalRequests++;
      *pInstNum = g_rc4TotalRequests & (pRC4Ctx->InstanceCount - 1);
      *pAccumulator = pRC4Ctx->Rc4Ins[*pInstNum]->Accumulator;

}

void rc4_revert(PRC4_INSTANCE_STATE pRC4State, DWORD cbData, BYTE* pbData)

{
      BYTE t = 0;
      for (int p = cbData - 1; p >= 0; p--)
      {
            *(pbData + p) = *(pbData + p) ^ pRC4State->SBOX[(pRC4State->SBOX[pRC4State->i] + pRC4State->SBOX[pRC4State->j]) & 0xFF];
            t = pRC4State->SBOX[pRC4State->i];

            pRC4State->SBOX[pRC4State->i] = pRC4State->SBOX[pRC4State->j];

            pRC4State->SBOX[pRC4State->j] = t;

            pRC4State->j = (pRC4State->j - pRC4State->SBOX[pRC4State->i]) & 0x0FF;

            pRC4State->i = (pRC4State->i - 1) & 0x0FF; 

      }
}

 
// Потокобезопасная обёртка для вызова RC4

void rc4_safe(pRC4_CONTEXT pRC4Ctx, DWORD InstNum, DWORD cbData, BYTE* pbData)

{
      EnterCriticalSection(&pRC4Ctx->Rc4Ins[InstNum]->CS);
      rc4(&pRC4Ctx->Rc4Ins[InstNum]->State, cbData, pbData);
      LeaveCriticalSection(&pRC4Ctx->Rc4Ins[InstNum]->CS);
}


void rc4(PRC4_INSTANCE_STATE pRC4State, DWORD cbData, BYTE* pbData)

{
      BYTE t = 0;
      for (int p = 0; p < cbData; p++)
      {
            pRC4State->i = (pRC4State->i + 1) & 0x0FF; 
            pRC4State->j = (pRC4State->j + pRC4State->SBOX[pRC4State->i]) & 0x0FF;
            t = pRC4State->SBOX[pRC4State->i];
            pRC4State->SBOX[pRC4State->i] = pRC4State->SBOX[pRC4State->j];
            pRC4State->SBOX[pRC4State->j] = t;
            *(pbData + p) = *(pbData + p) ^ pRC4State->SBOX[(pRC4State->SBOX[pRC4State->i] + pRC4State->SBOX[pRC4State->j]) & 0xFF];
      }
}

//RC4 Key Scheduling Algorithm (KSA)

void rc4_key(PRC4_INSTANCE_STATE pRC4State, DWORD cbData, BYTE* pbData)

{

      BYTE t = 0;
      for (pRC4State->i = 0; pRC4State->i < 256; pRC4State->i++)
            pRC4State->SBOX[pRC4State->i] = pRC4State->i;

      pRC4State->j = 0;
      for (pRC4State->i = 0; pRC4State->i < 256; pRC4State->i++)
      {
            pRC4State->j = (pRC4State->j + pRC4State->SBOX[pRC4State->i] 

                  + (*(pbData + pRC4State->i))  ) & 0x0FF;

      }

      t = pRC4State->SBOX[pRC4State->i];
      pRC4State->SBOX[pRC4State->i] = pRC4State->SBOX[pRC4State->j];   
      pRC4State->SBOX[pRC4State->j] = t;
}




int _tmain(int argc, _TCHAR* argv[])
{
	return 0;
}

[LongLong_2008]

这是头文件：

// Состояние экземпляра RC4

#include<windows.h>
typedef struct _RC4_INSTANCE_STATE {

      BYTE SBOX[256];   // S-блок 

      BYTE i;           // Регистр RC4

      BYTE j;           // Регистр RC4

}RC4_INSTANCE_STATE, *PRC4_INSTANCE_STATE;

 

// Экземпляр RC4

typedef struct _RC4_INSTANCE {

      // Кол-во байт выхода экземпляра

      DWORD                   Accumulator;      

      // Критическая секция для синхронизации потоков

      CRITICAL_SECTION        CS;  

      // Состояние экземпляра RC4

      RC4_INSTANCE_STATE      State;      

}RC4_INSTANCE, *pRC4_INSTANCE;

 

// Состояние генератора

typedef struct _RC4_CONTEXT {

      DWORD InstanceCount;         // Общее число экземпляров RC4

      DWORD AlwaysOne;             // Зарезервированно. Всегда равно 1

      pRC4_INSTANCE Rc4Ins[8];     // Экземпляры RC4

}RC4_CONTEXT, *pRC4_CONTEXT;       

 

// Глобальная переменная, определяющая состояние UUID-генератора

RC4_CONTEXT g_rc4SafeCtx;

// Глобальная переменная, определяющая выбор экземпляра RC4 

DWORD       g_rc4TotalRequests = 0;


typedef GUID UUID;

[xiaopoy]

LZ想纯copy别人代码就用？

[czbever]

他可能是要研究　反正CoCreateGUID直接用是可以的

[killbug2004]

BOOL SystemFunction036
 (
  PVOID pbBuffer,
  ULONG dwLen
 )
DESCRIPTION
MSDN documents this function as RtlGenRandom and declares it in ntsecapi.h. 

PARAMS
      pbBufer  [Out] Pointer to memory to receive random bytes. 
      dwLen  [In] Number of random bytes to fetch. 

RETURNS
   Success: TRUE 
   Failure: FALSE 
所以要用RtlGenRandom来代替SystemFunction036
BOOLEAN RtlGenRandom(

  __out  PVOID RandomBuffer,

  __in   ULONG RandomBufferLength

);

现在你不会要反汇编RtlGenRandom吧,我对随机数产生没兴趣,代码都这样了,相信你可以搞定,那几个编译错误我就不说了
不知道你要这个干嘛

[czbever]

牛人　这些都是用反汇编看的？

[czbever]

郁闷　会出异常：

// GUID.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<stdio.h>

#include"GUID.h"
#include< Rpc.h>


//BOOLEAN RtlGenRandom( __out  PVOID RandomBuffer, __in   ULONG RandomBufferLength);
RPCRTAPI RPC_STATUS RPC_ENTRY UuidCreate (OUT UUID __RPC_FAR * Uuid);
RPC_STATUS GenerateRandomNumber(BYTE* pbData, DWORD cbData);
void rc4_safe_select(pRC4_CONTEXT pRC4Ctx, DWORD* pInstNum, DWORD* pAccumulator);
void rc4_revert(PRC4_INSTANCE_STATE pRC4State, DWORD cbData, BYTE* pbData);
void rc4_safe(pRC4_CONTEXT pRC4Ctx, DWORD InstNum, DWORD cbData, BYTE* pbData);

void rc4(PRC4_INSTANCE_STATE pRC4State, DWORD cbData, BYTE* pbData);
void rc4_key(PRC4_INSTANCE_STATE pRC4State, DWORD cbData, BYTE* pbData);
void rc4_safe_key(pRC4_CONTEXT pRC4Ctx, DWORD InstNum, DWORD cbData, BYTE* pbData);
HRESULT __stdcall CoCreateGuid(GUID *pguid);


 RPC_STATUS RPC_ENTRY UuidCreate (OUT UUID __RPC_FAR * Uuid)
{
      RPC_STATUS ret;
      ret = GenerateRandomNumber((BYTE*)Uuid, sizeof(UUID));
      if (ret == RPC_S_OK)
	  {     
            Uuid->Data3 = (Uuid->Data3 & 0x0fff) | 0x4000;
            Uuid->Data4[0] = (Uuid->Data4[0] & 0x3F) | 0x80;
      }
      return ret;

}

void rc4_safe_key(pRC4_CONTEXT pRC4Ctx, DWORD InstNum, DWORD cbData, BYTE* pbData)

{

      EnterCriticalSection(&pRC4Ctx->Rc4Ins[InstNum]->CS);
      //RC4 Key Scheduling Algorithm (KSA)
      rc4_key(&pRC4Ctx->Rc4Ins[InstNum]->State, cbData, pbData);
      LeaveCriticalSection(&pRC4Ctx->Rc4Ins[InstNum]->CS);
}



RPC_STATUS GenerateRandomNumber(BYTE* pbData, DWORD cbData) 

{
      HMODULE  hModule=LoadLibrary(TEXT("Advapi32.dll"));
	  typedef BOOLEAN (*RtGenFunc)(PVOID,ULONG);
	  RtGenFunc RtlGenRandom;
	  if(!hModule)
	  {
		  MessageBox(NULL,TEXT("Load Error"),TEXT("Error"),64);
		  FreeLibrary(hModule);
		  return 0;
	  }
	  else 
	  {
		  
		   RtlGenRandom=(RtGenFunc)::GetProcAddress(hModule,"SystemFunction036");
		  if(RtlGenRandom == NULL )
		  {
			  MessageBox(NULL,TEXT("GetProc Error"),TEXT("Error"),64);
			  FreeLibrary(hModule);
			  return 0;
		  }
	  }
      DWORD Accumulator = 0;  
      DWORD InstNum;
      PVOID RandomKey;
      rc4_safe_select(&g_rc4SafeCtx, &InstNum, &Accumulator);
      if (Accumulator >= 500000)
      {
            if (!RtlGenRandom(RandomKey, 256))
                 return RPC_S_OUT_OF_MEMORY;
         
            rc4_safe_key(&g_rc4SafeCtx, InstNum, 256, (BYTE*)RandomKey);
      }
     
      rc4_safe(&g_rc4SafeCtx, InstNum, cbData, pbData);

	  FreeLibrary(hModule);
      return RPC_S_OK;

}


void rc4_safe_select(pRC4_CONTEXT pRC4Ctx, DWORD* pInstNum, DWORD* pAccumulator)

{
      g_rc4TotalRequests++;
      *pInstNum = g_rc4TotalRequests & (pRC4Ctx->InstanceCount - 1);
      *pAccumulator = pRC4Ctx->Rc4Ins[*pInstNum]->Accumulator;

}

void rc4_revert(PRC4_INSTANCE_STATE pRC4State, DWORD cbData, BYTE* pbData)

{
      BYTE t = 0;
      for (int p = cbData - 1; p >= 0; p--)
      {
            *(pbData + p) = *(pbData + p) ^ pRC4State->SBOX[(pRC4State->SBOX[pRC4State->i] + pRC4State->SBOX[pRC4State->j]) & 0xFF];
            t = pRC4State->SBOX[pRC4State->i];

            pRC4State->SBOX[pRC4State->i] = pRC4State->SBOX[pRC4State->j];

            pRC4State->SBOX[pRC4State->j] = t;

            pRC4State->j = (pRC4State->j - pRC4State->SBOX[pRC4State->i]) & 0x0FF;

            pRC4State->i = (pRC4State->i - 1) & 0x0FF; 

      }
}

 


void rc4_safe(pRC4_CONTEXT pRC4Ctx, DWORD InstNum, DWORD cbData, BYTE* pbData)

{
      EnterCriticalSection(&pRC4Ctx->Rc4Ins[InstNum]->CS);
      rc4(&pRC4Ctx->Rc4Ins[InstNum]->State, cbData, pbData);
      LeaveCriticalSection(&pRC4Ctx->Rc4Ins[InstNum]->CS);
}


void rc4(PRC4_INSTANCE_STATE pRC4State, DWORD cbData, BYTE* pbData)

{
      BYTE t = 0;
      for (int p = 0; p < cbData; p++)
      {
            pRC4State->i = (pRC4State->i + 1) & 0x0FF; 
            pRC4State->j = (pRC4State->j + pRC4State->SBOX[pRC4State->i]) & 0x0FF;
            t = pRC4State->SBOX[pRC4State->i];
            pRC4State->SBOX[pRC4State->i] = pRC4State->SBOX[pRC4State->j];
            pRC4State->SBOX[pRC4State->j] = t;
            *(pbData + p) = *(pbData + p) ^ pRC4State->SBOX[(pRC4State->SBOX[pRC4State->i] + pRC4State->SBOX[pRC4State->j]) & 0xFF];
      }
}

//RC4 Key Scheduling Algorithm (KSA)

void rc4_key(PRC4_INSTANCE_STATE pRC4State, DWORD cbData, BYTE* pbData)

{

      BYTE t = 0;
      for (pRC4State->i = 0; pRC4State->i < 256; pRC4State->i++)
            pRC4State->SBOX[pRC4State->i] = pRC4State->i;

      pRC4State->j = 0;
      for (pRC4State->i = 0; pRC4State->i < 256; pRC4State->i++)
      {
            pRC4State->j = (pRC4State->j + pRC4State->SBOX[pRC4State->i] 

                  + (*(pbData + pRC4State->i))  ) & 0x0FF;

      }

      t = pRC4State->SBOX[pRC4State->i];
      pRC4State->SBOX[pRC4State->i] = pRC4State->SBOX[pRC4State->j];   
      pRC4State->SBOX[pRC4State->j] = t;
}

HRESULT __stdcall CoCreateGuid(GUID *pguid)
{
  HRESULT result; // eax@3

  if ( !pguid  && IsBadWritePtr(pguid, 0x10u) )
  {
    result = -2147024809;
  }
  else
  {
    result = UuidCreate(pguid);
    if ( result != 1824 && result )
    {
      if ( result > 0 )
        result = (WORD)result | 0x80070000;
    }
    else
    {
      result = 0;
    }
  }
  return result;
}

const char* newGUID()
{
	static char buf[64] = {0};
	GUID guid;
	if (S_OK == ::CoCreateGuid(&guid))
	{
		_snprintf(buf, sizeof(buf)
			,"{%08X-%04X-%04x-%02X%02X-%02X%02X%02X%02X%02X%02X}"
			, guid.Data1
			, guid.Data2
			, guid.Data3
			, guid.Data4[0], guid.Data4[1]
		, guid.Data4[2], guid.Data4[3], guid.Data4[4], guid.Data4[5]
		, guid.Data4[6], guid.Data4[7]
		);
	}
	return (const char*)buf;
}

int _tmain(int argc, _TCHAR* argv[])
{
   printf(newGUID());
   printf("\r\n");
	return 0;
}

[killbug2004]

找到一篇俄文,看来省事了
http://blogs.gotdotnet.ru/personal/denish/PermaLink.aspx?guid=9fa0aea5-99fa-47b3-8f93-93e7bf8d0848

[czbever]

太牛了，俄文的！

[czbever]

f:\c\guid\guid\guid.cpp(24) : error C2491: 'UuidCreate' : definition of dllimport function not allowed
f:\c\guid\guid\guid.cpp(67) : error C3861: 'SystemFunction036': identifier not found
f:\c\guid\guid\guid.cpp(127) : warning C4018: '<' : signed/unsigned mismatch

用俄文的那边文章把函数拷贝进去，编译出这个错

[czbever]

pRC4Ctx->Rc4Ins[*pInstNum]->Accumulator这个未赋值

[czbever]

只找到一篇java的：

import java.net.*; 
import java.util.*; 
import java.security.*;

public class GuidCreator extends Object 
{ 

	private String seedingString =" "; 
	private String rawGUID = " "; 
	private boolean bSecure = false; 
	private static Random myRand; 
	private static SecureRandom mySecureRand; 

	private static String s_id; 

	public static final int BeforeMD5 = 1; 
	public static final int AfterMD5 = 2; 
	public static final int FormatString = 3; 

	static 
	{ 
		mySecureRand = new SecureRandom(); 
		long secureInitializer = mySecureRand.nextLong(); 
		myRand = new Random(secureInitializer); 
		try 
		{ 
			s_id = InetAddress.getLocalHost().toString(); 
		} 
		catch (UnknownHostException e)
		{ 
			e.printStackTrace(); 
		} 
	} 

	/* 
	* Default constructor. With no specification of security option, 
	* this constructor defaults to lower security, high performance. 
	*/ 
	public GuidCreator() { } 

	/* 
	* Constructor with security option. Setting secure true 
	* enables each random number generated to be cryptographically 
	* strong. Secure false defaults to the standard Random function seeded 
	* with a single cryptographically strong random number. 
	*/ 
	public GuidCreator(boolean secure)
	{ 
		bSecure = secure; 
	} 

	/* 
	* Method to generate the random GUID 
	*/ 
	private void getRandomGUID(boolean secure)
	{ 
		MessageDigest md5 = null; 
		StringBuffer sbValueBeforeMD5 = new StringBuffer(); 

		try 
		{ 
			md5 = MessageDigest.getInstance("MD5"); 
		}
		catch (NoSuchAlgorithmException e)
		{ 
			System.out.println("Error: " + e); 
		} 

		try 
		{ 
			long time = System.currentTimeMillis(); 
			long rand = 0; 

			if (secure)
			{ 
				rand = mySecureRand.nextLong(); 
			}
			else 
			{ 
				rand = myRand.nextLong(); 
			} 

			// This StringBuffer can be a long as you need; the MD5 
			// hash will always return 128 bits. You can change 
			// the seed to include anything you want here. 
			// You could even stream a file through the MD5 making 
			// the odds of guessing it at least as great as that 
			// of guessing the contents of the file! 
			sbValueBeforeMD5.append(s_id); 
			sbValueBeforeMD5.append(":"); 
			sbValueBeforeMD5.append(Long.toString(time)); 
			sbValueBeforeMD5.append(":"); 
			sbValueBeforeMD5.append(Long.toString(rand)); 

			seedingString = sbValueBeforeMD5.toString(); 
			md5.update(seedingString.getBytes()); 

			byte[] array = md5.digest(); 
			StringBuffer sb = new StringBuffer(); 
			for (int j = 0; j < array.length; ++j) 
			{ 
				int b = array[j] & 0xFF; 
				if (b < 0x10) sb.append('0'); 
				sb.append(Integer.toHexString(b)); 
			} 

			rawGUID = sb.toString(); 

		} 
		catch (Exception e) 
		{ 
			System.out.println("Error:" + e); 
		} 
	} 

	public String createNewGuid(int nFormatType, boolean secure)
	{ 
		getRandomGUID(secure); 
		String sGuid = " "; 
		if (BeforeMD5 == nFormatType)  
		{ 
			sGuid = this.seedingString; 
		} 
		else if (AfterMD5 == nFormatType)      
		{ 
			sGuid = this.rawGUID; 
		} 
        else          
		{ 
			sGuid = this.toString(); 
		} 
		return sGuid; 
	} 

	public String createNewGuid(int nFormatType) 
	{ 
		return this.createNewGuid(nFormatType, this.bSecure); 
	} 

	/* 
	* Convert to the standard format for GUID 
	* (Useful for SQL Server UniqueIdentifiers, etc.) 
	* Example: C2FEEEAC-CFCD-11D1-8B05-00600806D9B6 
	*/ 
	public String toString()    
	{ 
		String raw = rawGUID.toUpperCase(); 
		StringBuffer sb = new StringBuffer(); 
		sb.append(raw.substring(0,8)); 
		sb.append("-"); 
		sb.append(raw.substring(8, 12)); 
		sb.append("-"); 
		sb.append(raw.substring(12, 16)); 
		sb.append("-"); 
		sb.append(raw.substring(16, 20)); 
		sb.append("-"); 
		sb.append(raw.substring(20)); 

		return sb.toString(); 
	} 



public   static   void   main(String   args[])   
 { 
	for (int i=0; i< 100; i++) 
	{ 
		GuidCreator myGUID = new GuidCreator(); 
		System.out.println("Seeding String=" + myGUID.createNewGuid(GuidCreator.BeforeMD5)); 
		System.out.println("rawGUID=" + myGUID.createNewGuid(GuidCreator.AfterMD5)); 
		System.out.println("RandomGUID=" + myGUID.createNewGuid(GuidCreator.FormatString)); 
	} 
 } 

}