Well, the standard does not guarantee that a void * is the same size as a char * (having the "same representation and alignment requirements" as per the clause whiteflags quoted doesn't necessarily mean "identical representation"). In practice, since any pointer must survive a round-trip conversion (X * -> void * and back) a sizeof(void *) will normally be at least the size of any other pointer. That doesn't exclude a void * being larger than another pointer type. Which makes allocating a memory for a void * when you actually need memory for a char * unnecessarily wasteful - it may allocate more memory than needed.
That said, I have yet to come across any report or documentation of a compiler that supports a void * that is of different size than a char *. There is also no guarantee that pointers have any particular sizes.
In the end, however, I agree with iMalc's point. Code is easier to understand, and therefore easier to get right, if it explicitly does what is intended. In this case, you intend to allocate a char *. Using malloc(sizeof(void *)) may do nothing different, technically. But in your code, it obfuscates the meaning without any benefit. Code with obfuscated meaning is code that can trick a programmer (including yourself at some future date) into believing the code does something different than it actually does, and therefore introduce subtle bugs.
Incidentally, your code (even without changing it to work with allocate sizeof(void *)) has two potentially serious bugs.
Firstly, it does not check that phrases is non-NULL before allocating memory to phrases. It should.
Second, the allocation of phrases = malloc(sizeof(temp)+1); is flawed in several ways. sizeof(temp) will be the length of temp + 1 (i.e. sizeof(temp) catches the terminating zero byte in temp). Your code is therefore allocating more memory than needed. Your code will also break miserably if the code is ever restructured so temp is a pointer. For example, if your code is changed to this
Then sizeof(temp) will be the size of a pointer to char, not the size of the string. If sizeof(temp) < strlen(temp) ever occur, which it can and probably will, then the strcpy() call yields undefined behaviour.
char **phrases = NULL;
char *temp = "Hi there!";
phrases = malloc(sizeof(*phrases));
phrases = malloc(sizeof(temp)+1); /* Should check that phrases is non-NULL first */