Return to Answer

Yes a CSPRNG does require a secret random seed.

Keeping cryptographic requirements in mind OS developers have given multiple sources for fetching a good enough seed from sources of high entropy, and they may be available in the form of APIs . For example arc4random() family of functions in BSD type operating systems. If the APIs are not available, then we ourselves have to , implement drivers/software to capture randomness, treating the user itself as a source (mouse movements, sensor pulses (if smartphone)), although this may not be reliable*. Then that data can be fed to some kind of hash function like SHA-2 / SHA-3 on the fetched raw data to generate the pseudo random output required. arc4random uses ChaCha20 to generate Pseudo randomness from the raw data, which is excellent, given the fact that ChaCha20 using an incremented 64 bit counter internally can output 1 Zettabyte of pseudo random data with amazing diffusion . I'm mentioning these algorithms because they have stood the test of time and extensively subject to both linear and differential cryptanalysis.

When using other algorithms, you have to be careful though as CSPRNG's are notorious for being backdoored themselves, for example, the Dual_EC_DRBG 's kleptographic backdoors (that compromise the security of the random seed used), which made history.

But if the need for randomness is for generation of SSL certificates and thinks like that then it's better to rely on natural sources of entropy like radioactive decay. You can also use something simple like an army of lava lamps https://youtu.be/1cUUfMeOijg .

On further research on your question, I found this interesting :

In particular, data that is very random always has a high level of entropy, but data that has high entropy is not necessarily very random. https://www.google.com/amp/s/techbeacon.com/security/how-really-random-numbers-will-bolster-your-encryption%3famp

*In Linux we have /dev/urandom or /dev/random. But reading from it every time is not recommended as the OS can run out of entropy and hence it can affect the performance of your application.

Yes a CSPRNG does require a secret random seed.

Keeping cryptographic requirements in mind OS developers have given multiple sources for fetching a good enough seed from sources of high entropy, and they may be available in the form of APIs . For example arc4random() family of functions in BSD type operating systems. If the APIs are not available, then we ourselves have to , implement drivers/software to capture randomness, treating the user itself as a source (mouse movements, sensor pulses (if smartphone)), although this may not be reliable*. Then that data can be fed to some kind of hash function like SHA-2 / SHA-3 to generate the pseudo random output required. arc4random uses ChaCha20 to generate Pseudo randomness from the raw data, which is excellent, given the fact that ChaCha20 using an incremented 64 bit counter internally can output 1 Zettabyte of pseudo random data with good diffusion . I'm mentioning these algorithms because they have stood the test of time and extensively subject to both linear and differential cryptanalysis.

As a side note: When using other algorithms, you have to be careful though as CSPRNG's are notorious for being backdoored themselves, for example, the Dual_EC_DRBG 's kleptographic backdoors (that compromise the security of the random seed used), which made headlines .

But if the need for randomness is for generation of SSL certificates and thinks like that then it's better to rely on natural sources of entropy like radioactive decay. You can also use something simple like an army of lava lamps https://youtu.be/1cUUfMeOijg .

On further research on your question, I found this interesting :

In particular, data that is very random always has a high level of entropy, but data that has high entropy is not necessarily very random. https://www.google.com/amp/s/techbeacon.com/security/how-really-random-numbers-will-bolster-your-encryption%3famp

*In Linux we have /dev/urandom or /dev/random. But reading from it every time (like reading a file) is not recommended as the OS can run out of entropy and hence it can affect the performance of your application.

Yes a CSPRNG does require a secret random seed.

Keeping cryptographic requirements in mind OS developers have given multiple sources for fetching a good enough seed from sources of high entropy, and they may be available in the form of APIs . For example arc4random() family of functions in BSD type operating systems. If the APIs are not available, then we ourselves have to , implement drivers/software to capture randomness, treating the user itself as a source (mouse movements, sensor pulses (if smartphone)), although this may not be reliable*. Then that data can be fed to some kind of hash function like SHA-2 / SHA-3 on the fetched raw data to generate the pseudo random output required. arc4random uses ChaCha20 to generate Pseudo randomness from the raw data, which is excellent, given the fact that ChaCha20 using an incremented 64 bit counter internally can output 1 Zettabyte of pseudo random data with amazing diffusion . I'm mentioning these algorithms because they have stood the test of time and extensively subject to both linear and differential cryptanalysis.

When using other algorithms, you have to be careful though as CSPRNG's are notorious for being backdoored themselves, for example, the Dual_EC_DRBG 's kleptographic backdoors (that compromise the security of the random seed used), which made history.

But if the need for randomness is for generation of SSL certificates and thinks like that then it's better to rely on natural sources of entropy like radioactive decay. You can also use something simple like an army of lava lamps https://youtu.be/1cUUfMeOijg .

I found this interesting : https://www.google.com/amp/s/techbeacon.com/security/how-really-random-numbers-will-bolster-your-encryption%3famp

*In Linux we have /dev/urandom or /dev/random. But reading from it every time is not recommended as the OS can run out of entropy and hence it can affect the performance of your application.

Yes a CSPRNG does require a secret random seed.

Keeping cryptographic requirements in mind OS developers have given multiple sources for fetching a good enough seed from sources of high entropy, and they may be available in the form of APIs . For example arc4random() family of functions in BSD type operating systems. If the APIs are not available, then we ourselves have to , implement drivers/software to capture randomness, treating the user itself as a source (mouse movements, sensor pulses (if smartphone)), although this may not be reliable*. Then that data can be fed to some kind of hash function like SHA-2 / SHA-3 on the fetched raw data to generate the pseudo random output required. arc4random uses ChaCha20 to generate Pseudo randomness from the raw data, which is excellent, given the fact that ChaCha20 using an incremented 64 bit counter internally can output 1 Zettabyte of pseudo random data with amazing diffusion . I'm mentioning these algorithms because they have stood the test of time and extensively subject to both linear and differential cryptanalysis.

When using other algorithms, you have to be careful though as CSPRNG's are notorious for being backdoored themselves, for example, the Dual_EC_DRBG 's kleptographic backdoors (that compromise the security of the random seed used), which made history.

But if the need for randomness is for generation of SSL certificates and thinks like that then it's better to rely on natural sources of entropy like radioactive decay. You can also use something simple like an army of lava lamps https://youtu.be/1cUUfMeOijg .

On further research on your question, I found this interesting :

In particular, data that is very random always has a high level of entropy, but data that has high entropy is not necessarily very random. https://www.google.com/amp/s/techbeacon.com/security/how-really-random-numbers-will-bolster-your-encryption%3famp

*In Linux we have /dev/urandom or /dev/random. But reading from it every time is not recommended as the OS can run out of entropy and hence it can affect the performance of your application.

Yes a CSPRNG does require a secret random seed.

Keeping cryptographic requirements in mind OS developers have given multiple sources for fetching a good enough seed from sources of high entropy, and they may be available in the form of APIs . For example arc4random() family of functions in BSD type operating systems. If the APIs are not available, then we ourselves have to , implement drivers/software to capture randomness, treating the user itself as a source (mouse movements, sensor pulses (if smartphone)), although this may not be reliable*. Then that data can be fed to some kind of hash function like SHA-2 / SHA-3 on the fetched raw data to generate the pseudo random output required. arc4random uses ChaCha20 to generate Pseudo randomness from the raw data, which is excellent, given the fact that ChaCha20 using an incremented 64 bit counter internally can output 1 Zettabyte of pseudo random data with amazing diffusion . I'm mentioning these algorithms because they have stood the test of time and extensively subject to both linear and differential cryptanalysis.

When using other algorithms, you have to be careful though as CSPRNG's are notorious for being backdoored themselves, for example, the Dual_EC_DRBG 's kleptographic backdoors (that compromise the security of the random seed used), which made history.

But if the need for randomness is for generation of SSL certificates and thinks like that then it's better to rely on natural sources of entropy like radioactive decay. You can also use something simple like an army of lava lamps https://youtu.be/1cUUfMeOijg .

*In Linux we have /dev/urandom or /dev/random. But reading from it every time is not recommended as the OS can run out of entropy and hence it can affect the performance of your application.

Yes a CSPRNG does require a secret random seed.

Keeping cryptographic requirements in mind OS developers have given multiple sources for fetching a good enough seed from sources of high entropy, and they may be available in the form of APIs . For example arc4random() family of functions in BSD type operating systems. If the APIs are not available, then we ourselves have to , implement drivers/software to capture randomness, treating the user itself as a source (mouse movements, sensor pulses (if smartphone)), although this may not be reliable*. Then that data can be fed to some kind of hash function like SHA-2 / SHA-3 on the fetched raw data to generate the pseudo random output required. arc4random uses ChaCha20 to generate Pseudo randomness from the raw data, which is excellent, given the fact that ChaCha20 using an incremented 64 bit counter internally can output 1 Zettabyte of pseudo random data with amazing diffusion . I'm mentioning these algorithms because they have stood the test of time and extensively subject to both linear and differential cryptanalysis.

When using other algorithms, you have to be careful though as CSPRNG's are notorious for being backdoored themselves, for example, the Dual_EC_DRBG 's kleptographic backdoors (that compromise the security of the random seed used), which made history.

But if the need for randomness is for generation of SSL certificates and thinks like that then it's better to rely on natural sources of entropy like radioactive decay. You can also use something simple like an army of lava lamps https://youtu.be/1cUUfMeOijg .

I found this interesting : https://www.google.com/amp/s/techbeacon.com/security/how-really-random-numbers-will-bolster-your-encryption%3famp

*In Linux we have /dev/urandom or /dev/random. But reading from it every time is not recommended as the OS can run out of entropy and hence it can affect the performance of your application.