If you enter your function and the stack is at 0x100. Typically the stack grows downward, toward zero, from high addresses to low addresses. so if you then push one 4 byte item the stack "top" is now at 0xFC. Push another, 0xF8, and so on.
The other thing that is getting in the way here is ebp vs esp.
Generally a processor has a stack pointer, either a special or sometimes general purpose register that has specific instructions tied to it, push, pop, and perhaps stack pointer relative addressing loads and stores. Also it is not uncommon for compilers to consume a general purpose (or special purpose) register, different from the stack pointer, for a stack frame. Why? to make reading and debugging the compiler generated code a little easier.
Upon entry of the function for example you might make a copy of the stack pointer into this other register, and for the duration of the function that register doesnt move, this allows you to do relative addressing to that register to find local variables as well as function parameters (if this compiler and processor tend to pass parameters on the stack). So throughout the function you can access any one of these local variables with the same offset. If you didnt use a stack frame then, if, for optimization reasons (conservation of the stack memory) the stack pointer were dynamic within the function, then the relative offsets from the stack pointer to local variables and stack based function parameters would also be dynamic and harder to read and debug. (while saving stack space and returning a register for other uses, both optimizations).
In any case, functions that call functions need to have the stack pointer at the "top of stack" when the nested function is called so that that function can enjoy the stack as any other function and assume that it can use/destroy anything beyond the end of stack for its own purposes.