realloc not working despite using it on a malloc'ed string

Here:

buff = malloc(10);
buff = "hi";

You've reassigned the address held in buff...

You probably meant:

strcpy( buff, "hi" );

And, you need to capture the returned pointer from realloc() in case that function has relocated your data to grow/shrink the buffer.

Further, ALWAYS check return codes from any system call. You probably test if fopen() returned NULL. Well, memory allocation can fail, too!

char *buff = malloc( 10 );
if( buff == NULL ) {
    fprintf( stderr, "malloc failed\n" );
    exit( EXIT_FAILURE ); // probably not going to get much further
}

EDIT: That was too easy. Here's an annotated version that (omitting typos) should show how you should/could use realloc()

int main() {
    char *buff = malloc( 10 );
    if( buff == NULL ) {
        fprintf( stderr, "Failed to launch!\n" );
        exit( EXIT_FAILURE );
    }

    strcpy( buff, "hi" ); // should fit!
    puts( buff ); // working???

    printf( "%c\n", buff[0] ); // should be 'h'

    printf( "%p\n", &buff[0] ); // should be the same as...
    printf( "%p\n",  buff    ); // this

    { // NB: 'tmp' is only within the 'scope' of this pair of braces
        char *tmp = realloc( buff, 20 ); // delicately
        if ( tmp == NULL ) {
            // Here it is, but this need not be a "hard error"
            // Report problem, but could perhaps continue with same sized buffer, somehow...
            fprintf( stderr, "Cannot grow the buffer, but,,, ");
            printf( "still have '%s' and 'Good-bye'\n", buff );
            free( buff );
            exit( EXIT_FAILURE);
        }
        buff = tmp; // Got it. (Don't replace if "soft error" of tmp being NULL, of course)
    }

    printf( "%p\n", buff ); // just to see if block relocated

    free( buff ); // don't forget about this

    return 0;
}

Caveat: It's up to you, the programmer who 'reserves' blocks of heap memory, to track how big that block is and not "scribble" outside of that playground. free() will do the right thing, but between malloc() and free(), and made more complex with realloc() there is a lot of opportunity to overrun the buffer and invoke "undefined behaviour".

Taking this one step further...

In fact, on some occasions the code is better using only realloc() that "acts like malloc()" when it receives a NULL as the first parameter...

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    char sentence[] = "The  quick brown   fox jumps   over the lazy dog";
    char **words = NULL;

    // Chop up a mutable string (sentence), isolating each word
    // accessible via its own pointer.
    // realloc() "grows" the array of pointers to words.
    int i = 0; 
    for( char *p = sentence; (p = strtok( p, " " )) != NULL; p = NULL ) {
        char **tmp = realloc( words, (i+1) * sizeof *tmp );
        if ( tmp == NULL ) {
            fprintf( stderr, "realloc failed on %d - %s\n", i, p );
            free( words );
            exit( EXIT_FAILURE);
        }
        words = tmp;
        words[ i++ ] = p;
        printf( "cnt(%d) ", i ); // debugging
    }
    putchar( '\n' ); // debugging

    while( i-- ) // reverse order
        puts( words[i] ); 

    free( words );

    return 0;
}

Output

cnt(1) cnt(2) cnt(3) cnt(4) cnt(5) cnt(6) cnt(7) cnt(8) cnt(9)
dog
lazy
the
over
jumps
fox
brown
quick
The