Mensajes

El Plesk es una aplicación web donde puedes gestionar casi todo. Zonas DNS, puedes añadir cuentas de revendedor, usuarios normales, comprar dominios, y mil cosas. Pero al final acabé desinstalandolo y lo instalé todo por mi cuenta.

Ahora todo funciona perfectamente. El "bug" ese que me daba era en realidad del dovecot y era simplemente porque la carpeta de los mails de recividos no tenía bien los permisos. Cosa extraña ya que es un auto-instalable. Según he visto no es un error demasiado común pero lo solucioné modificando los permisos. Como dije todo funciona perfectamente. Lo único que me faltaría ahora es ver cómo puedo pasar los datos del antiguo servidor de correo al nuevo porque hay muchos usuarios creados en el antiguo, probablemente hayan muchos mails guardados y bueno, que no quiero que se pierdan.

¿Alguien conoce alguna forma de transferir la información de un servidor de correo a otro?

Supongo que tendré que montar otras mil sub-zonas DNS por toda la diferencia de dominios que hay usando el servidor...

Espero aclaración. Muchas gracias por la ayuda.

Vuelvo otra vez por aquí.

Resulta que ya lo he configurado todo pero ahora tengo otro problema. Los DNS de un dominio de prueba hacen del servidor de mail más memorizable pero ahora, creé un usuario de sistema llamado test, y en Thunderbird, el cliente de correo de Mozilla me conecta absolutamente todo bien, excepto que cuando voy a la bandeja de entrada me sale un aviso del programa diciendo:

Código [Seleccionar] Expandir


test@albateranoalvertedero.es respondió:
[SERVERBUG] Internal error occurred. Refer to server log for more information. [2014-04-03 20:36:17]


Presiento que ya estoy muy cerca. Debe de ser algún error tonto. He buscado en los logs y no encuentro ningún error ni nada como dice...

¿Alguna idea?

He decidido que lidiar con plesk me está llevando más tiempo del previsto. Lo voy a desinstalar e instalaré todo yo mismo.

Voy a usar ésta guía:
http://www.alcancelibre.org/staticpages/index.php/como-postfix-tls-y-auth

La parte del DNS es una cosa que se me resiste un poco más.
En esa guía pone esto:

Código [Seleccionar] Expandir


$TTL 86400
@ IN SOA dns1.isp.com alguien.algo.com (
2010061901 ; Número de serie
28800 ; Tiempo de refresco
7200 ; Tiempo entre reintentos
604800 ; tiempo de espiración
86400 ; Tiempo total de vida
)
@ IN NS dns1.isp.com.
@ IN NS dns2.isp.com.
@ IN A a.b.c.d
@ IN MX 10 mail
@ IN TXT "v=spf1 a mx -all"
mail IN A xx.xx.xx.xx
www IN A a.b.c.d
ftp IN A a.b.c.d

Ahí lo que en principio habría que cambiar seria la entrada de tipo A "mail" y añadir la ip del servidor de mail, no?

Pero ahora mismo estoy pensando que creo que eso va dirigido a un dominio cualquiera que quiera usar el servicio de mail.

¿Es posible que me haya confundido en todas las guías que he leido debido a que pensaba que eso era configuración del bind9 de lado del servidor de mail?

Si es así necesito una aclaración.

En cualquier caso eso quiere decir que no necesitaría bind9 en el servidor de mail para nada. Con la IP me basta, no? Creo que estoy empezando a iluminarme un poco...

Si hubiera que hacer alguna configuración con bind9 de lado del servidor de mail porfavor iluminadme.

[named.conf]

Estoy usando CentOS 6.

Los iptables están puestos por defecto para aceptar todas las conexiones (Ya lo cambiaré).

En principio no estoy completamente seguro de si la zona DNS está bien al 100% configurada. Pero es decir, el dominio me apunta bien a la IP del servidor, y de hecho por ejemplo en thunderbird puedo configurar la conexión y el único problema es que no me puede verificar la contraseña del usuario, pero detecta que el lugar es mail.dominiodeprueba.net, detecta al parecer los puertos, y conectar conecta pero lo que digo. No parece poder autentificar usuarios. Me dice al cabo de un ratito de comprobación que la contraseña puede ser incorrecta y tal.

Créeme que intento poner de mi parte dato000.

Mis conocimientos sobre estos temas no son demasiado amplios, pero el servidor de mail y tal venía configurado al instalar Parallels Plesk (Venía gratis). Es un Postfix. Para el DNS utiliza bind 9, SELinux está desactivado al parecer, Cyrus IMAP server, Procmail para filtrar correo, SpamAssassin, y... no sé si me dejo algo más ahora mismo.

Os voy a dejar la dirección del servidor para que podáis ver que contecta.
mail.albateranoalvertedero.es

Es una dirección de prueba.

Aquí pongo la configuración del archivo named.conf: (Una lástima que no haya spoilers para acortar el mensaje.)

Código [Seleccionar] Expandir

#ATTENTION!
#
#DO NOT MODIFY THIS FILE BECAUSE IT WAS GENERATED AUTOMATICALLY,
#SO ALL YOUR CHANGES WILL BE LOST THE NEXT TIME THE FILE IS GENERATED.
// $Id: named.conf,v 1.1.1.1 2001/10/15 07:44:36 kap Exp $
//
// Refer to the named(8) man page for details.  If you are ever going
// to setup a primary server, make sure you've understood the hairy
// details of how DNS is working.  Even with simple mistakes, you can
// break connectivity for affected parties, or cause huge amount of
// useless Internet traffic.

options {
       allow-recursion {
       };
listen-on-v6 { any; };
       version "none";
       directory "/var";
       auth-nxdomain no;
       pid-file "/var/run/named/named.pid";

// In addition to the "forwarders" clause, you can force your name
// server to never initiate queries of its own, but always ask its
// forwarders only, by enabling the following line:
//
//      forward only;

// If you've got a DNS server around at your upstream provider, enter
// its IP address here, and enable the line below.  This will make you
// benefit from its cache, thus reduce overall DNS traffic in the Internet.
/*
       forwarders {
               127.0.0.1;
       };
*/
       /*
        * If there is a firewall between you and nameservers you want
        * to talk to, you might need to uncomment the query-source
        * directive below.  Previous versions of BIND always asked
        * questions using port 53, but BIND 8.1 uses an unprivileged
        * port by default.
        */
       // query-source address * port 53;

       /*
        * If running in a sandbox, you may have to specify a different
        * location for the dumpfile.
        */
       // dump-file "s/named_dump.db";
};

//Use with the following in named.conf, adjusting the allow list as needed:

key "rndc-key" {
       algorithm hmac-md5;
       secret "CeMgS23y0oWE20nyv0x40Q==";
};

controls {
       inet 127.0.0.1 port 953
       allow { 127.0.0.1; } keys { "rndc-key"; };


Como ya dije, todo esto venía pre-instalado y configurado -se supone- por Parallels Plesk. Creo que debería venir configurado correctamente como para usarlo con las opciones del Parallels pero a lo mejor me equivoco... Precisamente me da miedo cambiar opciones por si lo destrozo todo...

[Para extender un poco más la información:]

Buenas a todos.

Espero que el tema esté creado en buen lugar.

Creo este tema porque tengo un par de problemas para configurar unos DNS.

Veréis. Tengo 3 servidores. Uno es un servidor exclusivamente de mail con un cliente postfix. Otro es sólamente para comprar dominios y apuntarlos al tercer servidor que es el que uso de almacenamiento para los distintos dominios.

La cuestión es que estoy configurando el servidor de mail para que se use por los dominios. Tengo configurada la entrada MX de las zonas DNS apuntando a la dirección del servidor pero no consigo hacer que funcione.

Cuando mando un mensaje desde mi correo de hotmail por ejemplo me llega automáticamente un mail de fallo. Y cuando intento enviar algo desde un mail de dominio simplemente no pasa nada. No me llega ningún mensaje ni al destinatario ni de error ni nada.

Esperaba que alguien pudiera echarme un cable. Llevo un par de días leyendo tutoriales sobre configuración de servidores de email, configuración de DNS, etcétera...

_________________________

Para extender un poco más la información:

El servidor de correo parece estar configurado correctamente y los dns apuntan bien. Pero mi intención es la siguiente:

Yo ya tengo usuarios de correo creados en otros dominios con el servidor de correo anterior. Me gustaría que éstos no los tuviera que volver a crear. Hay alguna forma de hacer que el servidor de mail nuevo adopte estas cuentas anteriormente creadas con otro servidor? Algo como migrar las cuentas?. Por cierto. Creo las cuentas desde un CPanel que me ofrece mi proveedor. Eso también servirá con el nuevo servidor? De momento puedo crear y borrar cuentas nuevas pero como no consigo enviar ni recivir mails casi que da igual...

Hola a todos!

Tengo un pequeño problema... Tengo el puntero estático de una dirección con todos sus offsets y estoy intentando obtener su valor pero... en Cheat Engine me muestra el valor correcto perfectamente, pero si intento buscar el valor con Autoit y la UDF NomadMemory no retorna la dirección correcta.

Código [Seleccionar] Expandir


#include <NomadMemory.au3>

Global $pid, $memory

; vit
Global $base_address[1] = [Hex(0x007C7B4C)]
Global $offset1[2] = [0, Hex(0x2f8)]

If WinGetProcess("*proccess*") == -1 Then
   MsgBox(16, "Info.", "No se encuentra el proceso")
Else
   $pid = WinGetProcess("*proccess*")

   $memory = _MemoryOpen($pid)

   $final_add = "0x" & $base_address[0]

   $sp2_cur_vit = _MemoryRead($final_add, $memory, 'dword')
   MsgBox(64, "Result:", $final_add & " -> " & $sp2_cur_vit)

   _MemoryClose($memory)
   Exit
EndIf

Eso es un pequeño ejemplo.

Aquí dejo una imágen:


Como podéis ver, la dirección base es 0x007C7B4C, la cual en este caso apunta a 0x0F7C7008. Pero la función _MemoryRead() del NomadMemory me devuelve "1760660224" como el valor the la dirección base 0x007C7B4C. Esto está corriendo todo al mismo tiempo. El Cheat Engine, el script, y el proceso pero obtengo dos valores diferentes... No lo entiendo.

Este es mi NomadMemory.au3:

Código [Seleccionar] Expandir


#include-once
#region _Memory
;=================================================================================================
; AutoIt Version:   3.1.127 (beta)
; Language:         English
; Platform:         All Windows
; Author:           Nomad
; Requirements:     These functions will only work with beta.
;=================================================================================================
; Credits:  wOuter - These functions are based on his original _Mem() functions.  But they are
;           easier to comprehend and more reliable.  These functions are in no way a direct copy
;           of his functions.  His functions only provided a foundation from which these evolved.
;=================================================================================================
;
; Functions:
;
;=================================================================================================
; Function:         _MemoryOpen($iv_Pid(, $iv_DesiredAccess(, $iv_InheritHandle)))
; Description:      Opens a process and enables all possible access rights to the process.  The
;                   Process ID of the process is used to specify which process to open.  You must
;                   call this function before calling _MemoryClose(), _MemoryRead(), or _MemoryWrite().
; Parameter(s):     $iv_Pid - The Process ID of the program you want to open.
;                   $iv_DesiredAccess - (optional) Set to 0x1F0FFF by default, which enables all
;                                       possible access rights to the process specified by the
;                                       Process ID.
;                   $if_InheritHandle - (optional) If this value is TRUE, all processes created by
;                                       this process will inherit the access handle.  Set to TRUE
;                                       (1) by default.  Set to 0 if you want it to be FALSE.
; Requirement(s):   A valid process ID.
; Return Value(s):  On Success - Returns an array containing the Dll handle and an open handle to
;                                the specified process.
;                   On Failure - Returns 0
;                   @Error - 0 = No error.
;                            1 = Invalid $iv_Pid.
;                            2 = Failed to open Kernel32.dll.
;                            3 = Failed to open the specified process.
; Author(s):        Nomad
; Note(s):
;=================================================================================================
Func _MemoryOpen($iv_Pid, $iv_DesiredAccess = 0x1F0FFF, $if_InheritHandle = 1)

   If Not ProcessExists($iv_Pid) Then
       SetError(1)
       Return 0
   EndIf

   Local $ah_Handle[2] = [DllOpen('kernel32.dll')]

   If @Error Then
       SetError(2)
       Return 0
   EndIf

   Local $av_OpenProcess = DllCall($ah_Handle[0], 'int', 'OpenProcess', 'int', $iv_DesiredAccess, 'int', $if_InheritHandle, 'int', $iv_Pid)

   If @Error Then
       DllClose($ah_Handle[0])
       SetError(3)
       Return 0
   EndIf

   $ah_Handle[1] = $av_OpenProcess[0]

   Return $ah_Handle

EndFunc

;=================================================================================================
; Function:         _MemoryRead($iv_Address, $ah_Handle(, $sv_Type))
; Description:      Reads the value located in the memory address specified.
; Parameter(s):     $iv_Address - The memory address you want to read from. It must be in hex
;                                 format (0x00000000).
;                   $ah_Handle - An array containing the Dll handle and the handle of the open
;                                process as returned by _MemoryOpen().
;                   $sv_Type - (optional) The "Type" of value you intend to read.  This is set to
;                               'dword'(32bit(4byte) signed integer) by default.  See the help file
;                               for DllStructCreate for all types.
;                               An example: If you want to read a word that is 15 characters in
;                               length, you would use 'char[16]'.
; Requirement(s):   The $ah_Handle returned from _MemoryOpen.
; Return Value(s):  On Success - Returns the value located at the specified address.
;                   On Failure - Returns 0
;                   @Error - 0 = No error.
;                            1 = Invalid $ah_Handle.
;                            2 = $sv_Type was not a string.
;                            3 = $sv_Type is an unknown data type.
;                            4 = Failed to allocate the memory needed for the DllStructure.
;                            5 = Error allocating memory for $sv_Type.
;                            6 = Failed to read from the specified process.
; Author(s):        Nomad
; Note(s):          Values returned are in Decimal format, unless specified as a 'char' type, then
;                   they are returned in ASCII format.  Also note that size ('char[size]') for all
;                   'char' types should be 1 greater than the actual size.
;=================================================================================================
Func _MemoryRead($iv_Address, $ah_Handle, $sv_Type = 'dword')

   If Not IsArray($ah_Handle) Then
       SetError(1)
       Return 0
   EndIf

   Local $v_Buffer = DllStructCreate($sv_Type)

   If @Error Then
       SetError(@Error + 1)
       Return 0
   EndIf

   DllCall($ah_Handle[0], 'int', 'ReadProcessMemory', 'int', $ah_Handle[1], 'int', $iv_Address, 'ptr', DllStructGetPtr($v_Buffer), 'int', DllStructGetSize($v_Buffer), 'int', '')

   If Not @Error Then
       Local $v_Value = DllStructGetData($v_Buffer, 1)
       Return $v_Value
   Else
       SetError(6)
       Return 0
   EndIf

EndFunc

;=================================================================================================
; Function:         _MemoryWrite($iv_Address, $ah_Handle, $v_Data(, $sv_Type))
; Description:      Writes data to the specified memory address.
; Parameter(s):     $iv_Address - The memory address you want to write to.  It must be in hex
;                                 format (0x00000000).
;                   $ah_Handle - An array containing the Dll handle and the handle of the open
;                                process as returned by _MemoryOpen().
;                   $v_Data - The data to be written.
;                   $sv_Type - (optional) The "Type" of value you intend to write.  This is set to
;                               'dword'(32bit(4byte) signed integer) by default.  See the help file
;                               for DllStructCreate for all types.
;                               An example: If you want to write a word that is 15 characters in
;                               length, you would use 'char[16]'.
; Requirement(s):   The $ah_Handle returned from _MemoryOpen.
; Return Value(s):  On Success - Returns 1
;                   On Failure - Returns 0
;                   @Error - 0 = No error.
;                            1 = Invalid $ah_Handle.
;                            2 = $sv_Type was not a string.
;                            3 = $sv_Type is an unknown data type.
;                            4 = Failed to allocate the memory needed for the DllStructure.
;                            5 = Error allocating memory for $sv_Type.
;                            6 = $v_Data is not in the proper format to be used with the "Type"
;                                selected for $sv_Type, or it is out of range.
;                            7 = Failed to write to the specified process.
; Author(s):        Nomad
; Note(s):          Values sent must be in Decimal format, unless specified as a 'char' type, then
;                   they must be in ASCII format.  Also note that size ('char[size]') for all
;                   'char' types should be 1 greater than the actual size.
;=================================================================================================
Func _MemoryWrite($iv_Address, $ah_Handle, $v_Data, $sv_Type = 'dword')

   If Not IsArray($ah_Handle) Then
       SetError(1)
       Return 0
   EndIf

   Local $v_Buffer = DllStructCreate($sv_Type)

   If @Error Then
       SetError(@Error + 1)
       Return 0
   Else
       DllStructSetData($v_Buffer, 1, $v_Data)
       If @Error Then
           SetError(6)
           Return 0
       EndIf
   EndIf

   DllCall($ah_Handle[0], 'int', 'WriteProcessMemory', 'int', $ah_Handle[1], 'int', $iv_Address, 'ptr', DllStructGetPtr($v_Buffer), 'int', DllStructGetSize($v_Buffer), 'int', '')

   If Not @Error Then
       Return 1
   Else
       SetError(7)
       Return 0
   EndIf

EndFunc

;=================================================================================================
; Function:         _MemoryClose($ah_Handle)
; Description:      Closes the process handle opened by using _MemoryOpen().
; Parameter(s):     $ah_Handle - An array containing the Dll handle and the handle of the open
;                                process as returned by _MemoryOpen().
; Requirement(s):   The $ah_Handle returned from _MemoryOpen.
; Return Value(s):  On Success - Returns 1
;                   On Failure - Returns 0
;                   @Error - 0 = No error.
;                            1 = Invalid $ah_Handle.
;                            2 = Unable to close the process handle.
; Author(s):        Nomad
; Note(s):
;=================================================================================================
Func _MemoryClose($ah_Handle)

   If Not IsArray($ah_Handle) Then
       SetError(1)
       Return 0
   EndIf

   DllCall($ah_Handle[0], 'int', 'CloseHandle', 'int', $ah_Handle[1])
   If Not @Error Then
       DllClose($ah_Handle[0])
       Return 1
   Else
       DllClose($ah_Handle[0])
       SetError(2)
       Return 0
   EndIf

EndFunc

;=================================================================================================
; Function:         _MemoryPointerRead ($iv_Address, $ah_Handle, $av_Offset(, $sv_Type))
; Description:      Reads a chain of pointers and returns an array containing the destination
;                   address and the data at the address.
; Parameter(s):     $iv_Address - The static memory address you want to start at. It must be in
;                                 hex format (0x00000000).
;                   $ah_Handle - An array containing the Dll handle and the handle of the open
;                                process as returned by _MemoryOpen().
;                   $av_Offset - An array of offsets for the pointers.  Each pointer must have an
;                                offset.  If there is no offset for a pointer, enter 0 for that
;                                array dimension. (Offsets must be in decimal format, NOT hex!)
;                   $sv_Type - (optional) The "Type" of data you intend to read at the destination
;                                address.  This is set to 'dword'(32bit(4byte) signed integer) by
;                                default.  See the help file for DllStructCreate for all types.
; Requirement(s):   The $ah_Handle returned from _MemoryOpen.
; Return Value(s):  On Success - Returns an array containing the destination address and the value
;                                located at the address.
;                   On Failure - Returns 0
;                   @Error - 0 = No error.
;                            1 = $av_Offset is not an array.
;                            2 = Invalid $ah_Handle.
;                            3 = $sv_Type is not a string.
;                            4 = $sv_Type is an unknown data type.
;                            5 = Failed to allocate the memory needed for the DllStructure.
;                            6 = Error allocating memory for $sv_Type.
;                            7 = Failed to read from the specified process.
; Author(s):        Nomad
; Note(s):          Values returned are in Decimal format, unless a 'char' type is selected.
;                   Set $av_Offset like this:
;                   $av_Offset[0] = NULL (not used)
;                   $av_Offset[1] = Offset for pointer 1 (all offsets must be in Decimal)
;                   $av_Offset[2] = Offset for pointer 2
;                   etc...
;                   (The number of array dimensions determines the number of pointers)
;=================================================================================================
Func _MemoryPointerRead ($iv_Address, $ah_Handle, $av_Offset, $sv_Type = 'dword')

   If IsArray($av_Offset) Then
       If IsArray($ah_Handle) Then
           Local $iv_PointerCount = UBound($av_Offset) - 1
       Else
           SetError(2)
           Return 0
       EndIf
   Else
       SetError(1)
       Return 0
   EndIf

   Local $iv_Data[2], $i
   Local $v_Buffer = DllStructCreate('dword')

   For $i = 0 to $iv_PointerCount

       If $i = $iv_PointerCount Then
           $v_Buffer = DllStructCreate($sv_Type)
           If @Error Then
               SetError(@Error + 2)
               Return 0
           EndIf

           $iv_Address = '0x' & hex($iv_Data[1] + $av_Offset[$i])
           DllCall($ah_Handle[0], 'int', 'ReadProcessMemory', 'int', $ah_Handle[1], 'int', $iv_Address, 'ptr', DllStructGetPtr($v_Buffer), 'int', DllStructGetSize($v_Buffer), 'int', '')
           If @Error Then
               SetError(7)
               Return 0
           EndIf

           $iv_Data[1] = DllStructGetData($v_Buffer, 1)

       ElseIf $i = 0 Then
           DllCall($ah_Handle[0], 'int', 'ReadProcessMemory', 'int', $ah_Handle[1], 'int', $iv_Address, 'ptr', DllStructGetPtr($v_Buffer), 'int', DllStructGetSize($v_Buffer), 'int', '')
           If @Error Then
               SetError(7)
               Return 0
           EndIf

           $iv_Data[1] = DllStructGetData($v_Buffer, 1)

       Else
           $iv_Address = '0x' & hex($iv_Data[1] + $av_Offset[$i])
           DllCall($ah_Handle[0], 'int', 'ReadProcessMemory', 'int', $ah_Handle[1], 'int', $iv_Address, 'ptr', DllStructGetPtr($v_Buffer), 'int', DllStructGetSize($v_Buffer), 'int', '')
           If @Error Then
               SetError(7)
               Return 0
           EndIf

           $iv_Data[1] = DllStructGetData($v_Buffer, 1)

       EndIf

   Next

   $iv_Data[0] = $iv_Address

   Return $iv_Data

EndFunc

;=================================================================================================
; Function:         _MemoryPointerWrite ($iv_Address, $ah_Handle, $av_Offset, $v_Data(, $sv_Type))
; Description:      Reads a chain of pointers and writes the data to the destination address.
; Parameter(s):     $iv_Address - The static memory address you want to start at. It must be in
;                                 hex format (0x00000000).
;                   $ah_Handle - An array containing the Dll handle and the handle of the open
;                                process as returned by _MemoryOpen().
;                   $av_Offset - An array of offsets for the pointers.  Each pointer must have an
;                                offset.  If there is no offset for a pointer, enter 0 for that
;                                array dimension.
;                   $v_Data - The data to be written.
;                   $sv_Type - (optional) The "Type" of data you intend to write at the destination
;                                address.  This is set to 'dword'(32bit(4byte) signed integer) by
;                                default.  See the help file for DllStructCreate for all types.
; Requirement(s):   The $ah_Handle returned from _MemoryOpen.
; Return Value(s):  On Success - Returns the destination address.
;                   On Failure - Returns 0.
;                   @Error - 0 = No error.
;                            1 = $av_Offset is not an array.
;                            2 = Invalid $ah_Handle.
;                            3 = Failed to read from the specified process.
;                            4 = $sv_Type is not a string.
;                            5 = $sv_Type is an unknown data type.
;                            6 = Failed to allocate the memory needed for the DllStructure.
;                            7 = Error allocating memory for $sv_Type.
;                            8 = $v_Data is not in the proper format to be used with the
;                                "Type" selected for $sv_Type, or it is out of range.
;                            9 = Failed to write to the specified process.
; Author(s):        Nomad
; Note(s):          Data written is in Decimal format, unless a 'char' type is selected.
;                   Set $av_Offset like this:
;                   $av_Offset[0] = NULL (not used, doesn't matter what's entered)
;                   $av_Offset[1] = Offset for pointer 1 (all offsets must be in Decimal)
;                   $av_Offset[2] = Offset for pointer 2
;                   etc...
;                   (The number of array dimensions determines the number of pointers)
;=================================================================================================
Func _MemoryPointerWrite ($iv_Address, $ah_Handle, $av_Offset, $v_Data, $sv_Type = 'dword')

   If IsArray($av_Offset) Then
       If IsArray($ah_Handle) Then
           Local $iv_PointerCount = UBound($av_Offset) - 1
       Else
           SetError(2)
           Return 0
       EndIf
   Else
       SetError(1)
       Return 0
   EndIf

   Local $iv_StructData, $i
   Local $v_Buffer = DllStructCreate('dword')

   For $i = 0 to $iv_PointerCount
       If $i = $iv_PointerCount Then
           $v_Buffer = DllStructCreate($sv_Type)
           If @Error Then
               SetError(@Error + 3)
               Return 0
           EndIf

           DllStructSetData($v_Buffer, 1, $v_Data)
           If @Error Then
               SetError(8)
               Return 0
           EndIf

           $iv_Address = '0x' & hex($iv_StructData + $av_Offset[$i])
           DllCall($ah_Handle[0], 'int', 'WriteProcessMemory', 'int', $ah_Handle[1], 'int', $iv_Address, 'ptr', DllStructGetPtr($v_Buffer), 'int', DllStructGetSize($v_Buffer), 'int', '')
           If @Error Then
               SetError(9)
               Return 0
           Else
               Return $iv_Address
           EndIf
       ElseIf $i = 0 Then
           DllCall($ah_Handle[0], 'int', 'ReadProcessMemory', 'int', $ah_Handle[1], 'int', $iv_Address, 'ptr', DllStructGetPtr($v_Buffer), 'int', DllStructGetSize($v_Buffer), 'int', '')
           If @Error Then
               SetError(3)
               Return 0
           EndIf

           $iv_StructData = DllStructGetData($v_Buffer, 1)

       Else
           $iv_Address = '0x' & hex($iv_StructData + $av_Offset[$i])
           DllCall($ah_Handle[0], 'int', 'ReadProcessMemory', 'int', $ah_Handle[1], 'int', $iv_Address, 'ptr', DllStructGetPtr($v_Buffer), 'int', DllStructGetSize($v_Buffer), 'int', '')
           If @Error Then
               SetError(3)
               Return 0
           EndIf

           $iv_StructData = DllStructGetData($v_Buffer, 1)

       EndIf
   Next

EndFunc


;==================================================================================
; Function:            SetPrivilege( $privilege, $bEnable )
; Description:        Enables (or disables) the $privilege on the current process
;                   (Probably) requires administrator privileges to run
;
; Author(s):        Larry (from autoitscript.com's Forum)
; Notes(s):
; http://www.autoitscript.com/forum/index.php?s=&showtopic=31248&view=findpost&p=223999
;==================================================================================

Func SetPrivilege( $privilege, $bEnable )
   Const $TOKEN_ADJUST_PRIVILEGES = 0x0020
   Const $TOKEN_QUERY = 0x0008
   Const $SE_PRIVILEGE_ENABLED = 0x0002
   Local $hToken, $SP_auxret, $SP_ret, $hCurrProcess, $nTokens, $nTokenIndex, $priv
   $nTokens = 1
   $LUID = DLLStructCreate("dword;int")
   If IsArray($privilege) Then    $nTokens = UBound($privilege)
   $TOKEN_PRIVILEGES = DLLStructCreate("dword;dword[" & (3 * $nTokens) & "]")
   $NEWTOKEN_PRIVILEGES = DLLStructCreate("dword;dword[" & (3 * $nTokens) & "]")
   $hCurrProcess = DLLCall("kernel32.dll","hwnd","GetCurrentProcess")
   $SP_auxret = DLLCall("advapi32.dll","int","OpenProcessToken","hwnd",$hCurrProcess[0],   _
           "int",BitOR($TOKEN_ADJUST_PRIVILEGES,$TOKEN_QUERY),"int*",0)
   If $SP_auxret[0] Then
       $hToken = $SP_auxret[3]
       DLLStructSetData($TOKEN_PRIVILEGES,1,1)
       $nTokenIndex = 1
       While $nTokenIndex <= $nTokens
           If IsArray($privilege) Then
               $ntokenvar=$ntokenindex-1
               $priv = $privilege[$ntokenvar]
           Else
               $priv = $privilege
           EndIf
           $ret = DLLCall("advapi32.dll","int","LookupPrivilegeValue","str","","str",$priv,   _
                   "ptr",DLLStructGetPtr($LUID))
           If $ret[0] Then
               If $bEnable Then
                   DLLStructSetData($TOKEN_PRIVILEGES,2,$SE_PRIVILEGE_ENABLED,(3 * $nTokenIndex))
               Else
                   DLLStructSetData($TOKEN_PRIVILEGES,2,0,(3 * $nTokenIndex))
               EndIf
               DLLStructSetData($TOKEN_PRIVILEGES,2,DllStructGetData($LUID,1),(3 * ($nTokenIndex-1)) + 1)
               DLLStructSetData($TOKEN_PRIVILEGES,2,DllStructGetData($LUID,2),(3 * ($nTokenIndex-1)) + 2)
               DLLStructSetData($LUID,1,0)
               DLLStructSetData($LUID,2,0)
           EndIf
           $nTokenIndex += 1
       WEnd
       $ret = DLLCall("advapi32.dll","int","AdjustTokenPrivileges","hwnd",$hToken,"int",0,   _
               "ptr",DllStructGetPtr($TOKEN_PRIVILEGES),"int",DllStructGetSize($NEWTOKEN_PRIVILEGES),   _
               "ptr",DllStructGetPtr($NEWTOKEN_PRIVILEGES),"int*",0)
       $f = DLLCall("kernel32.dll","int","GetLastError")
   EndIf
   $NEWTOKEN_PRIVILEGES=0
   $TOKEN_PRIVILEGES=0
   $LUID=0
   If $SP_auxret[0] = 0 Then Return 0
   $SP_auxret = DLLCall("kernel32.dll","int","CloseHandle","hwnd",$hToken)
   If Not $ret[0] And Not $SP_auxret[0] Then Return 0
   return $ret[0]
EndFunc  ;==>SetPrivilege
#endregion


Por cierto. Si uso la dirección dinámica final obtengo el valor correcto. No entiendo qué pasa. He probado con otras formas que he visto googleando pero aún nada.


___________________________________
En respuesta al post que estaba escrito en inglés:
Tenía el post escrito de otro foro (quiero decir que el post lo he escrito originalmente yo, no es un copy/paste de nadie) y estaba muy atareado así que como no vi ninguna regla que obligara a hablar en castellano (también puedo estar ciego) lo copié para no perder tiempo.

En fin. Disculpad las molestias en cualquier caso.

Muchas gracias por contestar.

Estuve sopesando más opciones y la verdad es que la opción que planteo en este tema ya no me es completamente necesaria pero sí que me gustaría saber cómo sería.

La opción por la que de momento estoy optando haciendo pruebas es cargar una dll al abrir el cliente. Pero sigo queriendo resolver mis dudas con lo que pregunté anteriormente.

Otra cosa más.¿ A qué te refieres con cambiar las variables como el dinero y demás? ¿Tienes algún ejemplo? El tipo de conexión es cliente-servidor y los datos importantes se cargan desde el servidor, por lo cual no pueden cambiar el valor del dinero ni de otras cosas sin tener acceso a mi servidor. De todos modos me interesa eso que planteas y me gustaría un poco más de información de cómo hacerlo. ¿Serviría un editor hexadecimal como por ejemplo XVI32?

Gracias.

P.D.: ¿Cómo haría para añadirle protección contra debuggers? Estoy buscando información por más sitios de todos modos, pero ya que la gente de aquí tiene buenos conocimientos no me parece que esté de más leer la explicación de alguien de aquí.

Buenas a todos.

Llevo muy poco tiempo en C++ y venía a hacer una consulta a ver si me podéis dar un poco de información.

Estoy haciendo un programa para ejecutar otro ejecutable que hay dentro del proyecto pero tengo problemas para hacerlo...

Primero que no sé ni siquiera si es posible eso, pero me he guiado un poco por este tema de aquí: http://foro.elhacker.net/programacion_cc/ejecutar_exe_desde_c-t310021.0.html

En principio el CreateProcess está claro, lo que no sé es cómo ejecutar un archivo que está incluido en el paquete. No sé si me termino de explicar... Todo el proyecto acabaría dentro de un sólo ejecutable. No es que el otro ejecutable estuviera en la carpeta del ejecutable final.

He probado con direcciones como "/archivo.exe" esperando que lo tomase como una dirección relativa al proyecto pero nope.

Para aclarar cosas vengo de Java, donde tampoco es que sea un experto pero me manejo.

Muchas gracias.

P.D.: Para más información decir que no lo voy a usar con fines malignos. Es para guardar el cliente editado de mi servidor de un juego para que no puedan hacer ediciones sobre él ya que hay muchas herramientas que fácilmente lo hacen. Pero si el ejecutable está dentro de mi ejecutable personalizado la cosa cambia.

P.D. 2: También he estado leyendo sobre los pipes para capturar el output de un programa. Pregunta 2: ¿Me serviría un pipe para capturar el output del programa sabiendo que el programa está dentro del mismo paquete?

Lo siento si son preguntas muy tontas. Gracias de antemano.

P.D. 3: Se me olvidaba que el ejecutable que va dentro del paquete no puedo descomprimirlo en otra carpeta que no sea la del juego porque requiere una serie de librerías que hay en la carpeta para iniciar. Y ahí está el problema, no quiero dejarlo a la vista en la carpeta del juego para que no puedan editar el cliente...

Cuando se cifra un ejecutable realmente se está creando un programa nuevo que "encapsula" el ejecutable cifrado.

El nuevo programa no está cifrado... si no, no podría ejecutarse. Este nuevo programa dispone de las rutinas necesarias para ir descifrando el ejecutable original y que éste pueda funcionar. Una forma de hacer esto es mediante el uso de una máquina virtual ( al estilo de .net y java).

Muchas gracias por la información. Buscaré más a fondo a partir de ahí.

Buenas a todos!

Quería ver si alguien podía iluminarme.

Imagino que todos, o casi todos, conocéis programas como el Themida. Lo que quiero saber es cómo hacer un programa de cifrado de ejecutables. Es decir, como el themida y tal. No como otros programas que lo que hacen es protegerlos con contraseña y tal... Creo que me explico, sino decídmelo. Si además podéis ponerme ejemplos de código o lo que veáis conveniente. Muchas gracias y ya busqué en google. (no fue la primera vez)