Get a segmentation fault through argv on purpose - c

Question

I want to write a small program, which, by user input through argv, gets a segmentation error. I am quite new to C but I think the following code does the job:
int main(int argc, char *argv[])
{
int bufferSize;
char * buffer[100];
unsigned int i;
if (argc > 1) {
bufferSize = atoi(argv[1]);
for (i = 0; i < bufferSize; ++i)
*( buffer + i ) = i;
}
return 0;
}
My idea is that the program intialize (?) a pointer to a buffer of a specific size. If the user then input a number larger then the buffer size it will write to uninitialized memory, hence get a seg. fault. Is this reasoning correct whatsoever?
Ps. When compiling,I get a assignment makes pointer from integer without a castwarning, can someone maybe tell me why that happens? Thanks

Answer 1

The most traditional way to purposely get a segmentation fault, that I've seen, is to write to NULL, e.g. something like:
*((char *) NULL) = 0;
You can use a command line argument as a simple boolean value to see if this should be done or not.
Note that writing to NULL is not actually guaranteed to cause a crash, it's simply undefined behavior so basically anything could happen (including causing nasal demons).
The warning is because you have an array of pointers, and try to assign an integer to a pointer in the array.

Answer 2

char * buffer[100]; is an array of pointer which points to some garbage locations by default.
Here *( buffer + i ) = i; you are trying to deference that area which doesn't belongs to you.
My guess is that, you wanted to create a buffer. so
char buffer[100]; is enough.

Answer 3

I would not worry about writing to cause a segmentation fault. Reading is sufficient enough. You stand a better chance of causing a segfault if the buffer is on the heap. This application fairly reliably segfaults for negative inputs less than -10 for me.
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
int main(int argc, char* argv[])
{
static const int array[10] = {0,1,2,3,4,5,6,7,8,9};
int * const heapArray = malloc(sizeof(array));
memcpy(heapArray,array,sizeof(array));
const int index = atoi(argv[1]);
printf("%i\n",heapArray[index]);
free(heapArray);
return 0;
}
The problem is, the result of malloc() can be much much larger than the requested size for most systems. So even for large values it does not segfault, it just returns whatever happens to be there in memory.
ericu#eric-phenom-linux:~$ ./segfault -5
Segmentation fault (core dumped)
ericu#eric-phenom-linux:~$ ./segfault 11
0
ericu#eric-phenom-linux:~$ ./segfault 100
0
ericu#eric-phenom-linux:~$ ./segfault 100
0
ericu#eric-phenom-linux:~$ ./segfault 1000
0
ericu#eric-phenom-linux:~$ ./segfault 10000
0
ericu#eric-phenom-linux:~$ ./segfault 100000
Segmentation fault (core dumped)