How to use /dev/random or urandom in C?

by

In general, it’s a better idea to avoid opening files to get random data, because of how many points of failure there are in the procedure.

On recent Linux distributions, the getrandom system call can be used to get crypto-secure random numbers, and it cannot fail if GRND_RANDOM is not specified as a flag and the read amount is at most 256 bytes.

As of October 2017, OpenBSD, Darwin and Linux (with -lbsd) now all have an implementation of arc4random that is crypto-secure and that cannot fail. That makes it a very attractive option:

char myRandomData[50];
arc4random_buf(myRandomData, sizeof myRandomData); // done!

Otherwise, you can use the random devices as if they were files. You read from them and you get random data. I’m using open/read here, but fopen/fread would work just as well.

int randomData = open("/dev/urandom", O_RDONLY);
if (randomData < 0)
{
    // something went wrong
}
else
{
    char myRandomData[50];
    ssize_t result = read(randomData, myRandomData, sizeof myRandomData);
    if (result < 0)
    {
        // something went wrong
    }
}

You may read many more random bytes before closing the file descriptor. /dev/urandom never blocks and always fills in as many bytes as you’ve requested, unless the system call is interrupted by a signal. It is considered cryptographically secure and should be your go-to random device.

/dev/random is more finicky. On most platforms, it can return fewer bytes than you’ve asked for and it can block if not enough bytes are available. This makes the error handling story more complex:

int randomData = open("/dev/random", O_RDONLY);
if (randomData < 0)
{
    // something went wrong
}
else
{
    char myRandomData[50];
    size_t randomDataLen = 0;
    while (randomDataLen < sizeof myRandomData)
    {
        ssize_t result = read(randomData, myRandomData + randomDataLen, (sizeof myRandomData) - randomDataLen);
        if (result < 0)
        {
            // something went wrong
        }
        randomDataLen += result;
    }
    close(randomData);
}

More Related Contents:

  1. printf anomaly after “fork()”
  2. How to generate a random integer number from within a range
  3. How to make child process die after parent exits?
  4. What is time_t ultimately a typedef to?
  5. How to calculate the CPU usage of a process by PID in Linux from C?
  6. What is the equivalent to Posix popen() in the Win32 API?
  7. How to recursively list directories in C on Linux?
  8. Why does this program print “forked!” 4 times?
  9. How does kernel get an executable binary file running under linux?
  10. How do I execute an external program within C code in Linux with arguments?
  11. Measure time in Linux – time vs clock vs getrusage vs clock_gettime vs gettimeofday vs timespec_get?
  12. stdout thread-safe in C on Linux?
  13. Creating a new directory in C
  14. POSIX API call to list all the pthreads running in a process
  15. Building a kernel module from several source files which one of them has the same name as the module
  16. Turn a simple socket into an SSL socket
  17. Is there an alternative to using time to seed a random number generation?
  18. How to get network adapter stats in linux/Mac OSX?
  19. Bind failed: Address already in use
  20. flock vs lockf on Linux
  21. Write to .txt file?
  22. Do forked child processes use the same semaphore?
  23. Implementation of multiple pipes in C
  24. Force free() to return malloc memory back to OS
  25. What’s a good C decompiler? [closed]
  26. Sharing memory between processes through the use of mmap()
  27. How to set the IP address from C in linux
  28. Size of pid_t, uid_t, gid_t on Linux
  29. How to print exact value of the program counter in C
  30. How do I lock files using fopen()?

Leave a Comment