How to derive a private/public keypair from a random seed? For RSA, my understanding is that large primes are found randomly to build a private/public keypair. If a static seed can be used in that random search process, it should be possible to derive the same public/private keypair reliably.
For a repeatable discovery of foundational large-primes, the search for random primes might begin with an initial random large number. Then a sequential evaluation of large numbers to detect if they are prime.
This could be used to virtually create a TLS-PSK kind of system but using the more widely deployed TLS algorithms (PSK isn't widely deployed). Therefore, TLS is leveraged and induced to work like a PSK-based system, by using the random seed to find the large primes. That is, the seed value is virtually the PSK &quot;symmetric key&quot;. Both parties derive the same private/public keypair from the large primes from the shared seed.
Are there major security flaws with this approach? Are there existing schemes that accomplish such a random seed process?
Advantages achieved:

Simple central distribution (PKI) - a central control server distributes &quot;seeds&quot; in the same manner as &quot;symmetric passwords&quot; that could conceivably be changed every 15 minutes.
Tooling - TLS protection with common libraries (eg. C# .Net Framework) - with a &quot;symmetric password&quot; like framework. (DTLS isn't common)

Compared to central keypair generation and distribution:

Processing is decentralised and more scalable if the central control server only needs to generate a cryptographically-random seed. (The search for the primes happens N times, where N is the amount of nodes using the shared seed).
Fewer bytes to communicate. If the seed value is fewer bytes than communicating a public/private keypair.

I have a conceptual new secure communication system in mind that would use these advantages.
How to derive a private/public keyset from a random seed?

In principle: seed a Cryptographically Strong Pseudo Random Number Generator with the random seed, and use it to generate the RSA key pair &quot;normally&quot;. For the later, we could use FIPS 186-4 B.3.2.

Are there major security flaws with this approach?

Yes, the obvious one: any entity knowing the seed can compute the private key. We need to trust every such entity beyond the designated holder of the private key to only use the seed to compute the public key.
As an aside, deterministic RSA key pair generation may need extra work to be protected from side-channel attacks (timing, power analysis).
There's also a functional issue: RSA key generation is rather slow, and implementations often have no firm stated upper bound on their execution time.