How can a 8-bit CPU calculate big numbers?
It's certainly possible to work with very large numbers even on 8 bit or 4 bit computers.  It's not very efficient, but it's possible.  The way this is done is by operating on the numbers in pieces, with the support of specific processor instructions.  

A common 8 bit microcontroller is the Atmel AVR series.  To add 8-bit numbers, it uses an instruction called ADD.  This instruction is used to add two register values together.  For example, you can do

LDI R16, 5
LDI R17, 10
ADD R16, R17
; R16 = 15


to add R16 and R17 and put the result in R16.  To add 16-bit numbers, you basically just do this multiple times.  However, there is a catch: the carry bit.  Another AVR instruction is ADC, for ADd with Carry.  This does exactly the same thing as ADD, but it also adds the carry flag.  Both ADD and ADC will set the carry flag if the addition operation overflows.  Say, if you add 128 to 128, you get 0 as a result with the carry flag set.  If you call ADC with the carry flag set, it will add 1 to the result.  Here is an example 16-bit addition:

LDI R16, 232
LDI R17, 3
; R17:R16 = 1000
LDI R18, 208
LDI R19, 7
; R19:R18 = 2000
ADD R16, R18
ADC R17, R19
; R16 = 184
; R17 = 11
; R17:R16 = 3000


This can be repeated as many times as necessary to add large numbers.  Note that a small amount of logic is required to support this: the ability to feed the carry flag into the carry in of the adder.  

A similar process can be used to multiply numbers.  Performing 16-bit multiplications on an 8-bit processor requires 4 8-bit multiplications and several additions.  The procedure is exactly the same as multiplying numbers by hand one digit at a time, except you use bytes instead of digits.  You will need to multiply all four possible byte pairings, then add them according to their place values.  Example in AVR ASM:

LDI R16, 232
LDI R17, 3
; R17:R16 = 1000
LDI R18, 208
LDI R19, 7
; R19:R18 = 2000
MUL R16, R18
; R1:R0 = R16*R18 (1s place product)
MOVW R3:R2, R1:R0
; R3:R2 = R16*R18
MUL R16, R19
; R1:R0 = R16*R19 (256s place product #1)
CLR R4
ADD R3, R0
ADC R4, R1
; R4:R3:R2 = R16*R18 + 256*R16*R19
MUL R17, R18
; R1:R0 = R17*R18 (256s place product #2)
ADD R3, R0
ADC R4, R1
; R4:R3:R2 = R16*R18 + 256*(R16*R19+R17*R18)
MUL R17, R19
; R1:R0 = R17*R19 (65536s place product)
CLR R5
ADD R4, R0
ADC R5, R1
; R5:R4:R3:R2 = R16*R18 + 256*(R16*R19+R17*R18) + 65536*R17*R19
; R5:R4:R3:R2 = 2000000


You'll notice that this is exactly how you work with numbers by hand on paper, but instead of working with base 10 digits, the CPU works with word sized blocks of bits - in this case, 8 bits.  

If you use a CPU that can work with more bits at a time, then working with large numbers gets easier as it requires fewer instructions.  However, you can use the same techniques to work with larger numbers than the instruction set supports directly.