Question: I don´t know how to securely pass a parameter via form with Cake.
The method I use now is as follows:

```
$this->Form->create('Post', array('label' => '', 'action' => '', 'url' => 'inseratAngenommen/'.$postId));

```

In the controller there stands:

```
function inseratAngenommen($id = null, $bs = null){
    //stuff
}

```

The poblem is that the user can modify the output number of $postId in the browser:

```
action="/cakephp/posts/inseratAngenommen/149" 

```

For that case I want to pass the parameter invisible in the HTML. Is that possible?
I thought of a method like the Form->PostLink provides. I couldn´t find anything.
Thanks in advance.

Answer: 
In C pointers are [not guaranteed to have the same size](http://c-faq.com/null/machexamp.html). Now in reality most implementations pointers will be the same size, but that is an implementation detail of the compiler.

From the [C Faq](http://c-faq.com/null/machexamp.html):

> 
> The old HP 3000 series uses a different addressing scheme for byte
>  addresses than for word addresses; like several of the machines above
>  it therefore uses different representations for char \* and void \*
>  pointers than for other pointers
> 
> 
> Depending on the ``memory model'' in use, 8086-family processors (PC
>  compatibles) may use 16-bit data pointers and 32-bit function
>  pointers, or vice versa.
> 
> 
> 

Also `*((char *)ptr) = 0x154` is not the same as `*((int *)ptr) = 0x154`. Because you are dereferencing the pointer you will write data the size of a `char` and the size of an `int` into the location pointed to by `ptr`. Assuming an 8 bit char and a 32 bit int, `*((char *)ptr) = 0x154` will write`0x154` to the memory address assigned to `ptr` and `*((int *)ptr) = 0x154` will write `0x0000000154` to the 4 bytes starting at the address assigned to `ptr`.
Technically speaking, the C standard only guarantees that sizeof(char) == 1, and the rest is up to the implementation. But on modern x86 architectures (e.g. Intel/AMD chips) it's fairly predictable.

You've probably heard processors described as being 16-bit, 32-bit, 64-bit, etc. This usually means that the processor uses N-bits for integers. Since pointers store memory addresses, and memory addresses are integers, this effectively tells you how many bits are going to be used for pointers. sizeof is usually measured in bytes, so code compiled for 32-bit processors will report the size of pointers to be 4 (32 bits / 8 bits per byte), and code for 64-bit processors will report the size of pointers to be 8 (64 bits / 8 bits per byte). This is where the limitation of 4GB of RAM for 32-bit processors comes from -- if each memory address corresponds to a byte, to address more memory you need integers larger than 32-bits.

In practice, pointers will be size 2 on a 16-bit system (if you can find one), 4 on a 32-bit system, and 8 on a 64-bit system, but there's nothing to be gained in relying on a given size