Is there a significant difference between using a in built random number generator vs using cryptographic random number generator?

I was going through the Crypto++ library RNG page and I was wondering is there any issues with using something like

 std::srand(std::time(nullptr)); //using the current time as seed 

compared to the one of the rng in crypto library?

I'm beginner in cryptography, but one possible argument could be that the crypto rng functions are collision resistant ? However, I'm not sure how much better/stronger they are quantitively

Non-cryptographic "random" sources are not suitable for cryptographic purposes because while they may produce values which are indeed different, the values may at least..

• perhaps have a predictable seed (often the time - predicting when a program started can cut the real entropy down to a few orders of values)
• perhaps rely on other low system entropy (consider a cloned VM between runs)
• behave badly or be logically less-complex in different environments (perhaps they use size_t and then target a 16 or 32-bit microcontroller)
• come from a quite limited pool (see DOOM m_random.c for an extreme case)
• even if the pool is large, a subset of the results may be sufficient to predict upcoming values if the ordering is always the same
• not be produced in constant time (potentially leaking information about internal state)

Yes

There is a huge difference.

There are four classes of “random” numbers, categorized by the cross-section of two basic properties:

         insecure                secure
   ┌──────────────────┐   ┌──────────────────┐
 p │       PRNG       │   │      CSPRNG      │
 s ├──────────────────┤   ├──────────────────┤
 e │      rand()      │   │                  │
 u │       LCG        │   │   /dev/urandom   │
 d │ Mersenne Twister │ ← │   MS CryptoAPI   │
 o │    XOR Shift     │   │  (and many more) │
   │       etc        │   │                  │
   └──────────────────┘   └──────────────────┘
                                   ↑
   ┌──────────────────┐   ┌──────────────────┐
   │       TRNG       │   │      STRNG       │
 t ├──────────────────┤   ├──────────────────┤
 r │  Noise Sampling  │   │  (a TRNG that    │
 u │ Radioactive Decay│   │     has been     │
 e │ Lightning Strikes│ → │   unbiased, or   │
   │ Double Pendulums │   │    “whitened” )  │
   │       etc        │   │                  │
   └──────────────────┘   └──────────────────┘

The pseudo-random numbers are the ones people tend to think of when we say “random number library”.

The insecure numbers are useful only for things like video games and other non-critical stuff.

Anything to do with security or cryptography, however, has to come from the secure side. Since it is possible to exhaust a STRNG we use CSPRNGs for just about everything. CSPRNGS are no less secure than a STRNG.

^{The arrows in the above diagram show the direction of travel for things like initialization and entropy renewal — something you probably don’t have to care about.}

The C++ Standard Library, with one (possible) exception, is all insecure PRNGs.

The only CSPRNG in the standard library (probably) is std::random_device, and it sucks. (Its various implementations have improved significantly since its introduction, but it is still a truly awful thing. I detest it so much I even wrote a small library to replace it in 2017^[1]: https://github.com/Duthomhas/CSPRNG )

However, if you are working with a specific cryptography API, stick with that. It may not be particularly C++ friendly, but it provides superior facilities to do what you intend to do with it.

If you really want to learn more about this stuff, I recommend taking a University-level course somewhere at the 300-level. Most of the stuff you can find on the internet about cryptography and security is diluted by nonsense written by well-meaning folks who don’t know what they’re talking about, leaving beginners with a really muddled view of it all.

^{1 • Way back when one popular implementation was still implementing Randall Munroe’s joke as a placeholder. More good reading at explainxkcd.com.}