proc    Hex2Dec,szHex
               push    ebx
         push    [szHex]
             call    strlen
              
            mov             ebx,eax
             mov             ecx,eax
             dec     ebx
         mov             edi,[szHex]
         xor             edx,edx
     h2dLoop:
                dec             ecx
         jl              h2dEnd
              
            movzx   eax,byte [edi+ecx]
          sub             al,48
               cmp             al,9 ; 0-9
          jle             h2dAdd
              
            sub             al,17
               cmp             al,6 ; A-F 
         jle             @F 
         
            sub     al,32
               cmp             al,6 ; a-f
          
    @@: add             al,10
       h2dAdd: ; We need a << 4 for each position left in string (* 16)
          push    ebx
         push    edx
         push    eax
         push    ecx
         sub             ebx,ecx ; Position in string
                mov     ecx,ebx
             ; 16^ebx. We can do << 4 * ebx
                mov             eax,4
               mul             ecx ; 4 * position
          mov     ecx,eax
             mov             eax,1
               shl             eax,cl ; eax = 16^ebx
               mov     ebx,eax
             pop             ecx
         pop             eax
         xchg    eax,ebx
             mul     ebx
         test    eax,eax
             cmovz   eax,ebx ; If < 10 use original value
             pop             edx
         add             edx,eax
             pop             ebx
         jmp             h2dLoop
     
    h2dEnd:
         pop             ebx
         mov             eax,edx
             ret
 endp

    ; !!!!!! Add support for > 32 bits 
      proc    Binary2Dec,szBinary
         push    ebx
         push    edi
         push    [szBinary]
          call    strlen
              mov             ecx,eax
             mov             ebx,eax
             dec             ebx
         mov             edi,[szBinary]
              xor             edx,edx 
    b2dLoop:
                dec             ecx
         jl              b2dEnd ; Less than 0

            movzx   eax,byte [edi+ecx]
          cmp             al,0x30 ; '0'
             je              b2dLoop
             
            ; Find position of ~0 in string and calculate value 
                push    ebx
         push    edx
         sub             ebx,ecx ; ebx = position from end 
          xchg    ebx,ecx
             mov             eax,1
               shl             eax,cl ; eax *= 2 for each postition left from end
          xchg    ecx,ebx
     @@: pop             edx
         add             edx,eax
             pop             ebx
         jmp             b2dLoop
             
    b2dEnd:
         pop             edi
         pop             ebx
         mov             eax,edx
             ret
 endp
        
    proc    strlen,szString
             push    edi
         mov             edi,[szString]
              mov             edx,edi
             mov             ecx,-1
              xor             eax,eax
             repnz   scasb
               dec             edi
         xchg    eax,edi
             sub             eax,edx
             pop             edi
         ret
 endp
    

The only problem is, how do I know, with some functions, how many bytes I will need?

3. Any links or pointers on how to do some of the other ones e.g. decimal to hexadecimal and decimal to any base.