How to allocate full memory pages - c++

Question

In C or C++, on Linux, I want to allocate heap memory in full pages of the system's memory page size.
(The purpose is that I want to increase the likelihood that harmful buffer overflows cause segmentation faults.)
When I allocate memory with C++ array new (pointer = new char[size]), where size is a multiple of sysconf(_SC_PAGESIZE), then still the (virtual) address the allocated memory will usually not be a multiple of sysconf(_SC_PAGESIZE), indicating that I've got a subset of a larger chunk, confirmed by the fact that writing to pointer[size] and a little bit beyond (forced buffer overflow) usually does not cause a segmentation fault.
My question here is, can I influence the memory allocation somehow to give me full memory pages.
The processor architecture I am interested in is x86_64 aka amd64. Operating system is either latest Ubuntu, or stable CentOS Linux (7.3), the latter comes with kernel 3.10 and gcc-4.8.
I do not care if the solution is in C or C++, therefore I ask to leave the C tag in this question.

Answer 1

1) Just switching from pointer = new char[size] to pointer = aligned_alloc(sysconf(_SC_PAGESIZE), size) resulted in proper page alignment and (so far, with small test programs) consistent generation of segmentation faults when exceeding the allocated range. As #JohnBollinger pointed out in his first comment to the question, the generation of segmentation faults is not guaranteed from the method of allocation alone. This can be fixed with 2):
2) The Linux man page for the function mprotect contains a complete example for restricting access to memory pages. The example also provides a signal handler for SIGSEGV, which I'm not interested in, default action (abort) is good enough for me. The example section from the man page follows. Note that applying mprotect to memory areas unrelated to mmap is a Linux-specific extension not covered by POSIX.
EXAMPLE
The program below allocates four pages of memory, makes the third
of these pages read-only, and then executes a loop that walks
upward through the allocated region modifying bytes.
An example of what we might see when running the program is the
following:
$ ./a.out
Start of region: 0x804c000
Got SIGSEGV at address: 0x804e000
Program source
#include <unistd.h>
#include <signal.h>
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/mman.h>
#define handle_error(msg) \
do { perror(msg); exit(EXIT_FAILURE); } while (0)
static char *buffer;
static void
handler(int sig, siginfo_t *si, void *unused)
{
printf("Got SIGSEGV at address: 0x%lx\n",
(long) si->si_addr);
exit(EXIT_FAILURE);
}
int
main(int argc, char *argv[])
{
char *p;
int pagesize;
struct sigaction sa;
sa.sa_flags = SA_SIGINFO;
sigemptyset(&sa.sa_mask);
sa.sa_sigaction = handler;
if (sigaction(SIGSEGV, &sa, NULL) == -1)
handle_error("sigaction");
pagesize = sysconf(_SC_PAGE_SIZE);
if (pagesize == -1)
handle_error("sysconf");
/* Allocate a buffer aligned on a page boundary;
initial protection is PROT_READ | PROT_WRITE */
buffer = memalign(pagesize, 4 * pagesize);
if (buffer == NULL)
handle_error("memalign");
printf("Start of region: 0x%lx\n", (long) buffer);
if (mprotect(buffer + pagesize * 2, pagesize,
PROT_READ) == -1)
handle_error("mprotect");
for (p = buffer ; ; )
*(p++) = 'a';
printf("Loop completed\n"); /* Should never happen */
exit(EXIT_SUCCESS);
}
Attribution of the preceding quote:
This page is part of release 4.04 of the Linux man-pages project.
A description of the project, information about reporting bugs, and
the latest version of this page, can be found at http://www.kernel.org/doc/man-pages/.