u/InternationalSky5209

Hello fellow cryptographers.

This has been a personal research project of mine. As a physics student I thought of using non-linear dynamics of chaotic systems (in this case Lorenz + Chebyshev) for pseudo-random bit generation.

The generator has passed NIST SP 800-22 test suite as well as some other statistical tests such as Poker, LZC, Serial Correlation, Chi-Square and Shannon Entropy. Further red teaming (next bit prediction) was done using machine learning modes such as Linear/Logistic Regression, Decision Trees (ExtraTrees, HistGradientBoosting) and a Feedforward Neural Network. All ML models failed to predict over baseline.

So in short, the generator uses Argon2id as a seeding mechanism. It derives a 1024 bit key from a user password. Then those bits are spliced and used as seeds for chaotic systems (in which the bits are used to prime the initial parameters of the chaotic systems). Then an XOR operation is done on both outputs of the chaotic systems which gives the final bitstream.

So as I mentioned earlier this is a personal research project of mine. I am a physics student hence the option of using chaotic systems. Now I know, that, previously people had discouraged me from working on this deeming chaos based PRNG's as 'Snake-Oil' but I felt that this niche application of chaos based systems in cryptography was something worth researching on!!. (So here we are).

Now, I would love to hear your feedback on this project. Any tips to better it is also welcome.

I know further testing is required (like TestU01 and Dieharder). I will try to do it in future. It would be wonderful if some of you could red team the PRNG further using ML based models such as LSTM, Transformers or CNN/RNN. Anyhow, pasting link to the repository, do check out and tell your thoughts on this.

https://github.com/SS-Kadam/Lorenz-Chebyshev-PRNG.git

Hello, Redditors. This is a personal research project of mine and wanted some input/feedback on the project.

So the project uses Non-linear dynamics of chaotic systems to generate a Pseudo-Random bitstream. The algorithm pipeline uses Argon2id as seeding mechanism.

The pipeline is as follows (in short):

Password - Argon2id (1024 bit key) - Key division - Bits are used to prime Lorenz and Chebyshev chaotic systems - Transient response discarded (initial bits) - XOR of both chaotic outputs - Final pseudo random bitstream.

PRNG Evaluation:

a) Validated by NIST SP 800-22 test suite. Passed all 15 tests.

b) Evaluated by statistical tests such as Serial Correlation, Chi-square, LZC, Shannon Entropy, Poker test.

c) Evaluation of PRNG by ML based attacks. Next bit prediction failed by machine-learning models such Linear/Logistic Regression, Decision Trees (ExtraTrees, HistGB Regressors) and Feedforward Neural Network (MLP).

Note: a) PRNG is not to be mistaken for a CSPRNG (further testing regarding this required).

b) Security analysis by ML models such as LSTM, Transformers, CNN, RNN is left as future work. (Actually my device doesn't have specs/crashes when I try to run the above models).

Link of GitHub Repository includes: https://github.com/SS-Kadam/Lorenz-Chebyshev-PRNG.git

a) Entire source code along with modules for bit generation.

b) Test suites including NIST (updated) and other statistical tests for evaluation.

c) Files to check throughput, visualization plots of chaotic systems

d) Implementation file for verifying or further testing.

This has been a passion/personal research project. Would love to hear you inputs and feedback. I personally lack the specs to run the high end ML models for red teaming (would be delighted if anyone helps in that regard). If anyone interested for further testing check out the repository. Open for collab or any thing similar.

I built a chaotic PRNG using Lorenz + Chebyshev maps (with Argon2id seeding) — looking for feedback

I’ve been working on a custom pseudo-random number generator based on chaotic systems and wanted to share it here for review and critique.

Core idea
The generator combines:

• Lorenz system (continuous chaotic dynamics via RK4)
• Chebyshev map (discrete chaotic transformation)
• XOR-based mixing of both outputs
• Argon2id → used to derive a high-entropy 1024-bit seed from a user password

Pipeline:
Password → Argon2id → Seed → Lorenz + Chebyshev → XOR → Bitstream

Implementation details

• Warm-up phase: first 10,000 iterations discarded
• High-precision arithmetic (mpmath) used
• Output written as binary stream (.BIN)
• User-controlled output length

What I’ve included in the repo

• Core PRNG implementation (modular: Lorenz + Chebyshev + main)
• Statistical test suite (Entropy, LZC, Poker, Serial Correlation, Chi-square)
• Updated NIST SP 800-22 test wrapper (all 15 tests)
• Throughput benchmarking
• Visualization (Lorenz attractor, Chebyshev maps, LLE)

Reproducibility

• Fixed test vector included (bit slice + SHA-256 of full output)
• Deterministic under identical parameters and environment

Evaluation

• Passed standard statistical tests (NIST SP 800 22+other tests). (details in README)
• Also did some ML-based red-teaming (regression + tree-based models + neural network)
• Models failed to predict future bits beyond baseline

Important note
This is NOT claimed to be cryptographically secure.
The goal is to explore chaotic systems in PRNG design and evaluate their empirical behavior.

Looking for feedback on:

• Design choices (Lorenz + Chebyshev + XOR)
• Finite precision / floating-point concerns
• Potential weaknesses (periodicity, state recovery, etc.)
• Better ways to evaluate robustness (beyond what I’ve done)

GitHub repo: https://github.com/SS-Kadam/Lorenz-Chebyshev-PRNG.git

I’d appreciate any serious critique — especially from people familiar with PRNG design or randomness testing.