Hice hace algún tiempo un código en asm para ampliar la última sección, si lo quieres pídelo. El mecanismo es este:

• Le sumas al raw size  de  la  última  sección el tamaño que quieres ampliarla.
• Le sumas al virtual size el SectionAlignment.
• Le sumas al  SizeOfImage  el tamaño que quieres ampliar la  última sección y guardas el archivo.

Salu2

A ver, para aclarar conceptos le llamaremos "stub" al stub del crypter y "archivo a cifrar" al archivo que quieres meter a continuación del stub cifrado y listo para que el stub lo desencripte y ejecute ok?

(1) Al raw size de la última sección del stub le sumas el tamaño del archivo a cifrar.
(2) Al virtual size de la última sección del stub le sumas el Section Aligement.
(3) Al size of image del stub le sumas el tamaño del archivo a cifrar.
(4) Pones el archivo a cifrar a continuación del stub y todo listo.

Así tiene que funcionarte perfectamente, luego solo te queda extraer el archivo a cifrar del stub, que puedes saber donde empieza calculando cuanto ocupa el stub a partir del PE, te dejo una función: (No uso las estructuras en esta función por que me la pidieron hace tiempo y no me apetecia postear todo el módulo, pero la puedes adaptar fácilmente si quieres )

Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (Dst As Any, Src As Any, ByVal cLen As Long)
 
Private Sub Form_Load()
    MsgBox "El EOF está en el byte: " & GetEOF("C:\file.exe")
    End
End Sub
 
Function GetEOF(Path As String) As Long
 
    Dim ByteArray() As Byte
    Dim PE As Long, NumberOfSections As Integer
    Dim BeginLastSection As Long
    Dim RawSize As Long, RawOffset As Long
 
    Open Path For Binary As #1
        ReDim ByteArray(LOF(1) - 1)
        Get #1, , ByteArray
    Close #1
 
    Call CopyMemory(PE, ByteArray(&H3C), 4)
    Call CopyMemory(NumberOfSections, ByteArray(PE + &H6), 2)
    BeginLastSection = PE + &HF8 + ((NumberOfSections - 1) * &H28)
    Call CopyMemory(RawSize, ByteArray(BeginLastSection + 16), 4)
    Call CopyMemory(RawOffset, ByteArray(BeginLastSection + 20), 4)
    GetEOF = RawSize + RawOffset
 
End Function

En cuanto al ejemplo en ASM que comentaba: (FASM)

; ****************************************************************************
; ***  Código que amplía 0xFF bytes la última sección de un ejecutable.    ***
; ***                                                                      ***
; ***    -> Le sumamos al raw size  de  la  última  sección el tamaño que  ***
; ***       queremos ampliarla.                                            ***
; ***    -> Le sumamos al virtual size el SectionAlignment.                ***
; ***    -> Le sumamos al  SizeOfImage  el tamaño que queremos ampliar la  ***
; ***       última sección y guardamos el archivo.                         ***
; ****************************************************************************
 
include 'H:\archivos de programa\fasm\include\win32ax.inc'
 
.code
start:
	; Usamos la pila para gurdar nuestras variables
	sub esp, 20
	; [esp+0]  -> El handle del archivo
	; [esp+4]  -> Handle del archivo mapeado
	; [esp+8]  -> Lo que sería el "ImageBase" del archivo proyectado
	; [esp+12] -> SectionAligement
	; [esp+16] -> NumberOfSections
	; Sobran dos bytes por el alineamiento de la pila
 
	; Mapeamos el archivo en memoria con 40 bytes de más
	invoke CreateFile, ruta, GENERIC_READ+GENERIC_WRITE, FILE_SHARE_WRITE+FILE_SHARE_READ, 0, OPEN_EXISTING, 0,0
	mov dword[esp], eax
	invoke GetFileSize, eax, 0
	add eax, 0x2600 ; <--- Tamaño a ampliar
	mov esi, dword[esp]
	invoke CreateFileMapping, esi, 0, PAGE_READWRITE, 0, eax, 0
	mov [esp+4], eax
	invoke MapViewOfFile, eax, FILE_MAP_ALL_ACCESS, 0, 0, 0
	mov [esp+8], eax
 
	; Obtenemos los datos necesarios del PE
	mov ebx, dword[eax+0x3C] ; EBX = Signature
	mov edi, dword[eax+0x3C] ; Guardamos también en edi la posición del signature para usarla luego
	add ebx, eax
	add edi, eax
 
	add dword[ebx+0x50], 0xFF ; Le sumamos al SizeOfImage el tamaño a ampliar
	mov eax, dword[ebx+0x38]
	mov [esp+12], eax
	mov ax, word[ebx+0x6]
	mov [esp+16], ax
 
	; Obtenemos los datos necesarios de la última sección
	mov ax, word[esp+16]
	dec eax
	mov edx, 0x28
	mul edx
	add edi, eax
	add edi, 248 ; 248 = Tamaño OptionalHeader
 
	add dword[edi+16], 0xFF ; Le sumamos al RawSize el tamaño a ampliar
	mov eax, dword[esp+12]
	add dword[edi+8], eax	; Le sumamos al VirtualSize el SectionAlignment
 
 
	; Liberamos memoria, cuadramos la pila y salimos
	mov esi, esp
	invoke CloseHandle, dword[esi]
	invoke CloseHandle, dword[esi+4]
	invoke UnmapViewOfFile, dword[esi+8]
	add esp, 20
	invoke ExitProcess, 0
 
 
 
	ruta db 'H:\h.exe', 0 ; La ruta del archivo a tratar
 
.end start
 

Salu2

Lo que tienes que hacer es sumar o en hexadecimal los dos o en decimal los dos (VB te devuelve los números en decimal, así que súmalos así) recuerda que decimal y hexadecimal no son más que formas de representar números binarios (ceros y unos)

Lo primero, por que obtienes los valores en hexadecimal y luego los pasas a decimal con HexToDec para sumarlos?? 

Lo segundo, pones el archivo a cifrar a continuación del stub o en su caso rellenas los bytes necesarios?? Por que si no te va a dar error xD

Y bueno no se que más decirte, por el trozo de código que pones parece que está bien, haz pruebas con el código en ensamblador que te he pasado (espero que no se me haya olvidado ningún paso) por que tiene que funcionar

Pues yo si que no se como no pongas más código jajaja Prueba a hacerlo con el código en ensamblador que te e puesto a ver si también te falla o no, pero no debería. Si mañana saco un rato y no lo has solucionado te hago un ejemplo simple