General protection / core dump "boundary" - c

Question

I spoke with a friend about an algorithm, where I need to read data past end of the "variable".
He said I always can do this in safe way, but I disagree.
I know this is undefined behavior, however the person who said it, is really experienced in C. As you can see below, it really works for small number of bytes.
Here is example of the idea, but bit it is "over the top".
#include <stdint.h>
#include <stdio.h>
const uint64_t a = 100;
int main(){
const char *s = (const char *) &a;
printf("%d\n", s[1530]); // this works
// printf("%d\n", s[15300]); // this doesn't
}
Access will be read only and I will mask it so I don't care about reading the junk.
In reality I need just 16 bytes after the variable.
Also variable does not need to be const, but it very well might be const.
Is this safe, at least for small number of bytes?

Answer 1

You and your friend are speaking at cross-purposes.
Undefined behaviour means "not defined in the standard," often to avoid constraining implementations.
Behaviour left undefined may be defined by a particular implementation, but:
not be portable to other systems or implementations
not be portable to future versions of the same implementation
depending on what guarantees the implementation makes, it may anyway be badly supported
You haven't told us your platform or implementation, so all we can say is "this is undefined behaviour," because we only have the standard to go on.
If your implementation does make some guarantee that's relevant, and you have some platform-specific reason to believe it will keep working ... then at least bear in mind that the same code will not work elsewhere.
If, as seems more likely, the code just happens to do the right thing, at the moment, with the current code on the current version of one specific implementation ... then it could break at any time.

Answer 2

(Maybe I misunderstand what you are trying to do, if so, I just delete this answer again:-) ).
If you are trying to read from a memory segment you don't have access to (it could belong to another process), most OS/CPU will sent your process a 'Segment violation' signal. This signal will usual terminates your process.
You can (only experimental, I would say) intercept this signal, eg:
#include <stdio.h>
#include <signal.h>
#include <setjmp.h>
#include <stdint.h>
static /*sig*/jmp_buf segv_env;
static void * old_segv_sig;
static void segv_handler(int s) { /*sig*/longjmp(segv_env,s); }
int safe_read_check(void * mem,size_t sz)
{
int safe;
size_t i;
int r;
safe = 0;
old_segv_sig = signal( SIGSEGV, segv_handler );
if( /*sig*/setjmp( segv_env /*,1*/ ) == 0 )
{
for( i = 0 ; i < sz ; i++)
r = ((char*)mem)[i];
// no signals
safe=1;
}
signal( SIGSEGV, old_segv_sig ); // restore signal handler
return safe;
}
const uint64_t a = 100;
int main()
{
const char *s = (const char *) &a;
if( safe_read_check( (void*)&s[153],16 ) )
printf("safe\n");
else
printf("unsafe\n");
if( safe_read_check( (void*)&s[15300000L], 16 ))
printf("safe\n");
else
printf("unsafe\n");
return 0;
}