Código genérico:

.386    
.model flat, stdcall
option casemap:none
assume fs:nothing
 
.data
var1 db 'k',0,'e',0,'r',0,'n',0,'e',0,'l',0,'3',0,'2',0
var2 db 'K',0,'E',0,'R',0,'N',0,'E',0,'L',0,'3',0,'2',0
 
.code
start:
mov eax, fs:[030h]
mov eax, [eax + 0ch]
mov eax, [eax + 0ch]
xor edx, edx
mov esi, 0Fh
 
KERNEL:
mov eax, [eax]
mov ebx, [eax + 030h]
 
CMPSTR1:
mov cl, byte ptr [ebx + edx]
cmp byte ptr [offset var1 + edx], cl
jnz CMPSTR2
inc edx
cmp edx, esi
jz EXIT
jmp CMPSTR1
 
CMPSTR2:
mov cl, byte ptr [ebx + edx]
cmp byte ptr [offset var2 + edx], cl
jnz KERNEL
inc edx
cmp edx, esi
jz EXIT
jmp CMPSTR1
 
EXIT:
mov eax, [eax + 018h]
 
end start

Código con filtro:

mov eax, fs:[030h]
mov eax, [eax + 0ch]
mov eax, [eax + 0ch]
KERNEL:
mov eax, [eax]
mov ebx, [eax + 030h]
mov ecx, 00320033h
cmp ecx, [ebx + 0ch]
JNZ KERNEL
mov eax, [eax + 018h]

mov eax, fs:[030h]
mov eax, [eax + 0ch]
mov eax, [eax + 0ch]
mov eax, [eax]
mov eax, [eax]
mov eax, [eax + 018h]

Bueno leyendo un poco acerca de la PEB y entendiendo como localizaban el BaseAddress de kernel32, recordé que había un código que hicieron rehicieron y mejor dicho xD, bueno ese código dejo de funcionar en 7 donde se agrego Kernelbase.dll y obligó a cambiar el código. Tras pruebas mi código se baso en buscar el orden de carga de las librerías, y ese orden se respeta desde XP hasta 7 tanto en 64 como 32 bits.

Un agradecimiento a Lord, y ya implementaré un método genérico  .
Saludos!

Amigo, primeramente 2 detalles te recomendaría que llames a la función especificando el tipo de códificación de caracteres ANSI o UNICODE respectivamente A y W.
Ejemplo:


Ahora tu problema además puede deberse a que no estableces el directorio donde escribir el archivo para ello te recomiendo FtpSetCurrentDirectoryA
Prueba y nos comentas..
Saludos

Hola, lamento replicar en un tema algo antiguo pero quisiera aportar una experiencia que quizá también vaya de acuerdo a el objeto que se busca.

Hace algún tiemp trabajando en una función por accidente deje un número muy amplio y escribí en un archivo esa cantidad de bytes, esa cantidad se acerco a 6GB, y en un instante el PC se trabó y empezo a consumir toda la ram progresivamente, llego a 1GB rapidamente cuando llegí apenas a escribir 1 GB, y lo mejor que el proceso se volvió imparable, la unica opción fue reiniciar.

La verdad esta experiencia me encanto y pues esperemos ver que opinan.
Saludos, y rectifico S.O : Windows 7 Ultimate, programado en C.

EternalIdol  muy buen ejemplo.

Un 70% no sería mucho! 
+1 Leo!

Para saber exactamente por que no funciona te recomiendo leas los enlaces e informan en valor que debe retornar cada API, usa GetLastError y así identificaras el problema.

Saludos!

Hola, que tal amigo, mira hace muy poco me tope con estas API, y te hago 2 preguntas

Primero, debes especificar si usaras la API para unicode o ansi, te recomiendo ANSI y llamarías a las API así:
InternetOpenA
InternetConnectA
FtpGetFileA

Pesta.png esta en root del FTP de donde lo quieres bajar?, si no es así debes pasarle el path completo.

"C:\A.png" -> Aquí tienes otro error recuerda que \ se representa en \\, así que te deberia quedar así:
"C:\\A.png".

Aquí te dejo más información sobre las API, te recomiendo leer un poquito más.
http://msdn.microsoft.com/en-us/library/aa385096(v=vs.85).aspx
http://msdn.microsoft.com/en-us/library/aa384363(v=vs.85).aspx
http://msdn.microsoft.com/en-us/library/aa384157(v=vs.85).aspx

Saludos.

Espero que más de que te sirva la función, la analices y aprendas de ella, seguramente así será más de utilidad.

Saludos y me alegra que te aya servido pero toma en cuenta lo que te dije.

Hola amigo buen día, analice tu problema, y creo que alguna vez me tope con algo así, el hecho de esto es que hay sacar el número de números que compongan a la cifra, para esto usamos el operador mod y reducimos el archivo en su ultima cifra hasta llegar al último, te hice un ejemplo sencillo en una función espero te sea de útilidad, cualquier duda avisanos. Saludos

#include <stdio.h>
 
char * Cadena(int number, char * cadena);
 
int main(void)
{
    printf("%s ", Cadena(1667,"abcdefgh")); //return "affg"
    getchar();
}
 
char * Cadena(int number, char * cadena)
{
     int i = 0;
     int tNum = 0;
     int ilen = 0;
     int altNum = number;
     int * n = NULL;
     char * cadenareturn;
     while (number > 0)
     {
           tNum = number % 10;
           number = number / 10;
           ilen++;
     }
     n = (int *) malloc (sizeof(int) * ilen);
     for (i = (ilen - 1); i >= 0; i--)
     {
         n[i] = altNum % 10;
         altNum /= 10;
     }
     cadenareturn = (char *) malloc(ilen);
     memset(cadenareturn, 0, ilen + 1);
     for (i = 0; i < ilen; i++)
     {
         cadenareturn[i] = cadena[n[i]-1];
     }
     free(n);
     return cadenareturn;
}

Vale BlackZeroX te explico.
Te lo pongo de la siguiente forma, las secciones definen la estructura del archivo, entendiendo de tal forma que la suma de todas ellas, más los parámetros (Cabecera PE) dan como resultado el peso del archivo, cuando se agrega información extra al final del archivo, la suma de los valores de las secciones mas la cabecera no dará el peso final del archivo, por ende antivirus suelen poner firmas al detectar este desbalance como Avira o F-PROT, Así que lo que este código hace es detectar el tamaño de la información extra agregada y la balancea en base al FileAlignment, luego se actualizan los valores de la ultima sección (VirtualSize y SizeOfRawData) y el SizeOfImage, balanceando el archivo como si fuera información natural de la última sección, evitando así detecciones.

Espero que te aya quedado claro, cualquier duda con gusto tendrá su respuesta.