The Impact of AI on the Future of Cryptographic Security
Advisor: Joshua Winter
In this world where threats against privacy are evolving faster than ever, encryption has long served as our first line of defense against hacking and “bad-faith” actors. However, with the rapid advancement of AI and other technologies, which help in hacking, this project aims to explore how AI can be used to strengthen encryption. My research explores how AI can enhance cybersecurity and resist emerging threats. Through academic research, interviews with cybersecurity experts, and experimentation with different programs and modules involving cryptography and encryptions. I seek to understand whether AI-involved systems are more resistant to brute-force attacks or normal methods. I will conduct research with my mentor, Mr. Sällström, who is a data storage expert, remotely. This project will also examine academic articles, cybersecurity reports, and recently published case studies on AI-driven encryption and protection models. Machine learning models will be used to generate cryptographic keys that will be compared to traditional encryption techniques. I expect that AI-generated cryptographic keys will demonstrate higher barriers compared to traditional encryption methods, making them a lot more resistant to pattern-based attacks. Through this project, I hope to learn about new security and encryption concepts that have been re-introduced upon the recent rise of AI and LLMs.
Project Blog
Week 0: Introduction
Hi, my name is Victor and I will be researching how AI impacts encryption and cybersecurity in the modern day. I am going to be working remotely with an expert in AI and LLM models. I will educate people on the effects that AIs can have in modern society. I will take all kinds of research and experiments to see how exactly AI can protect our data better than traditional models.
Week 1: A Little Exploration
Hello guys, welcome back to my blog! As I look around myself, I realize how much work still remains to be done. This week, I sharpened my research by incorporating how bad-faith actors (hackers misusing AI) and the general risks of AI will impact technology. Cryptography keeps our information safe and ultimately the world more secure. I’ve compiled a list of main points from each of the chosen research papers and documents to know where to go after this. I admit that terms such as “homomorphic encryption” were somewhat difficult to get a hold of, but I’m starting to see how AI deal with encryption on a deeper layer compared to more traditional models such as RSA. I’ve been looking at AI and I have noticed that it offers cool twists, in that it generates keys right away. It works far more “randomly”. I have started with looking at three of the many papers that I have to work with. One on neural networks that learn encryption (Meraouche et al., 2021), another on how AI can boost quantum security (Radanliev, 2024), and one that talks about the stability of AI systems when using cool new encryption tools (Cano Garcia et al., 2022). Starting next week, I will start a literature review that focuses on AI’s role in cryptography, its generation for secure keys (that lock your information), and potentially quantum-resistant approaches (approaches that deal with the looming possibility of actualized quantum computing). Next week, I hope that I can reach out to expert researchers. I am looking forward to gaining insights on how these technologies will be involved in real-world cases.
Week 2: Neural Dive-Ins and Cryptographic Insights
Welcome back to the Senior Blog! This second week has seen a lot of progress with the gathering of comprehensive information. What I have discovered has intrigued me. AI is able to generate new keys continuously based on the environmental data, which includes things such as network traffic or even random quantum noise. AI can form “libraries” of the encryption data and methods such as RSA (Rivest–Shamir–Adleman) public cryptosystem. It does this by enhancing entropy and adapting to emerging threats. Currently, I have identified three major companies that are utilizing AI extensively in cryptographic security. Google’s focus is on practical experimentation with AI tools and laying a blueprint for AI’s exact development and function in the future. OpenAI has researched several examples, among those inputs that trick machine learning models. What could this be used for? Cryptanalysis (breaking codes or security systems) or defense systems against it. I have noticed that IBM has done extensive research in using AI to develop post-quantum algorithms and enhance security systems, such as quantum key distribution in response to the slow, yet, ever looming threat of quantum computing. IBM’s AI detects real-time threats to its cryptographic systems.
Traditional methods for key generation and protection rely on rules like signature-based intrusion detection. Their weakness lies in that they are unable to react to unseen or unknown threats effectively. AI’s use of machine learning to spot unusual patterns works, because these methods are able to adapt to new threats due to the disproportionate amount of training data they have access to.
Now I will bring you specifically to the articles and notes. Radanliev (2024) explains how in classical cryptography, AI enhances cryptanalysis by identifying vulnerabilities in the associated encrypted data as well as strengthening it against all kinds of brute force attacks. AI can serve as a catalyst for more efficient usage methods. The article also speaks of how quantum computing marks a shift in the focus of existing cryptographic systems, particularly of those that rely on mathematical principles. Meraouche (2021) focuses on two distinct periods: Early models from around 2000 to more recent advancements around 2016. Just like how people have their own experiences without having their brain programmed to do so, these neural networks learn encryption without being explicitly programmed.
I will make sure all of you are kept up to date with my research. See you soon!
Works Cited:
Radanliev, P. (2024). Artificial intelligence and quantum cryptography. Journal of Analytical Science and Technology, 15(1), Article 6. https://doi.org/10.1186/s40543-024-00416-6
Meraouche, I., Dutta, S., Tan, H., & Sakurai, K. (2021). Neural networks-based cryptography: A survey. IEEE Access, 9, 122086–122112. https://doi.org/10.1109/ACCESS.2021.3109635
Week 3: When the Keys Don't Lie
Hey, welcome back to my blog! This week I came across quite interesting discoveries. While working through the code, I noticed that PyTorch works better than TensorFlow and chose that one to work with. I re-read my notes from the sources I chose and took more detailed notes. Writing the notes from different angles aided in seeing the grand perspective. The big thing is that I created a python keygen.py. However, before we get thoroughly into this, it is time that I introduced you all to the Chi-Square Test. A Chi-Square Test is a method used to determine if there is a significant relationship between two variables. One sets up a table for independence and observed frequencies. The Chi-Square Statistic measures how far the observed counts (O) deviate from the expected counts (E). The formula is:
χ² = Σ [(O - E)² / E], where you sum this over all categories. A bigger χ² means a bigger difference between what you saw and what you would expect by chance. I trained a mini neural network in generating byte-like output. In the first run, I generated 1,000 keys and 1,000 AES keys. I used the Runs Test to refine my data. The Runs Test checks how many times a binary sequence flips from 0 to 1 or 1 to 0. The Runs Test gives us the actual number of runs, the expected number of runs, and the difference helps us to evaluate the randomness. The results were fascinating to say the least. For my AES Keys: Chi-Square: 222.75, p = 0.9283. That is actually quite close to the results I would expect. The high p-value close to 1 means that AES keys have a statistically even byte distribution. What this suggests is that strong randomness goes all around with an even spread across 0-255 values. With the AI Keys, Chi-Square: 752128.26, p = 0.0000. It’s not as good of a sign. The p value being equal to 0 means that the distribution is very non-random. What I have to do is clean up the values and fix the model. It needs to be more random, and stop outputting these clustered values. What I have left is to run a few more comparative analyses, summarize the implications from the sources to cryptography and AI as a whole, and show with visualizations and a presentation the synthesis of all this data.
I hope you enjoyed reading my blog. See all of you next week!
Week 4: Refining for Randomness Testing
Welcome back to my blog! This week, I have built on last week’s experiment, in which I tested AI-generated keys against traditional AES keys by using randomness tests. With 1,000 AES keys, I tested their randomness with the Chi-Square Test and Runs Test. Chi-Square = 222.75, p-value = 0.9283, shows a strong amount of randomness with an even byte distribution (0-255). The AI keys were not as good. From the article “Artificial Intelligence in Zero-Knowledge Proofs: Transforming Privacy in Cryptographic Protocols” and my ongoing research into the matter, I have gone further in my approach of comparing AI-generated keys with traditional ones. The key insight before was that the high p-value for the AES keys aligns with their expected randomness levels, while their poor performance means that the training data might have to be a bit larger. According to the article, computational demands and potential biases in AI models can limit the overall performance.
My actual data must be trained on a larger dataset of random binary sequences in order to address the clustering issues. It needs an improved GAN, using PyTorch, which is what I find preferable. I need to generate 10,000 keys using Python’s os.urandom or a PRNG like Mersenne Twister. After using the NIST Statistical Test Suite in regards to the Randomness Tests, I will have a comprehensive randomness evaluation. The practice experiment provided initial data and simulated the AI’s key performance abilities. I aim to bring AI keys closer to the standard. I will be able to create visualizations from this data. I need to finalize the analysis of AI’s strengths and weaknesses. I expect to be done with the experiment by the end of next week. I am excited to see the full results. If any of you want to give me specific input on GAN optimization and visualizations, simply reach out.
See you next time!
Week 5: AI vs AES - Closing the Gap in Key Randomness
Welcome back to my blog! Last week, I outlined my plans to build a more powerful GAN, aiming to see the true difference between AI-generated keys and traditional cryptographic standards like AES. I created a PyTorch GAN with spectral norm, dropout, batch normalization, and Wasserstein loss. My binary_key_gan folder includes a generator.py, discriminator.py, train.py, utils.py, and requirements.txt. After installing the requirements, I trained the GAN and got these as my results:
Epoch 0: D_loss = 1.7528, G_loss = 1.0856
Epoch 50: D_loss = -0.9384, G_loss = 1.0450
Epoch 100: D_loss = -0.1046, G_loss = 1.1311
Epoch 150: D_loss = -0.2804, G_loss = 1.7509
Epoch 200: D_loss = 0.0646, G_loss = 1.0067
Epoch 250: D_loss = 0.1476, G_loss = 1.6328
Epoch 300: D_loss = -0.1305, G_loss = 1.8090
Epoch 350: D_loss = 0.1780, G_loss = 1.7424
Epoch 400: D_loss = 0.0924, G_loss = 1.7151
Epoch 450: D_loss = -0.3462, G_loss = 1.3139
Epoch 500: D_loss = -0.1306, G_loss = 3.8443
Epoch 550: D_loss = 0.1225, G_loss = 3.3301
Epoch 600: D_loss = 0.0477, G_loss = 2.4287
Epoch 650: D_loss = 0.0269, G_loss = 2.8236
Epoch 700: D_loss = -0.0231, G_loss = 2.7157
Epoch 750: D_loss = 0.3379, G_loss = 2.8061
Epoch 800: D_loss = 0.6251, G_loss = 3.7308
Epoch 850: D_loss = 0.0465, G_loss = 3.1919
Epoch 900: D_loss = 0.0235, G_loss = 3.4400
Epoch 950: D_loss = 0.0274, G_loss = 3.8966
The Generator tries to generate fake keys that look real. The Discriminator tries to detect if a key is really from the dataset or simply fake. I noticed that it stopped at 950 epochs and not 1000. Every 50 epochs, it saves a generator model file. Binary represents data using only 0s and 1s. However, I wanted 10,000 binary keys. To scale up to 10,000 keys, I adjusted the latent space and increased training epochs. PyCharm helped organize the folder structure and scripts cleanly. I successfully saved 10,000 binary keys. The keys are 128-bit. These are real binary sequences, not merely toy data.
Yet, I wanted to investigate the randomness and if there were any anomalies or patterns. Each key was extremely unpredictable. This data is very close to the ideal. Over 6,000 of my AI-generated keys scored entropy values above 0.999, which is extremely close to the ideal. That alone marks a significant improvement in the progress of this project.
With the new entropy and distribution results, it’s clear that this GAN version is significantly more capable than the earlier version. The gap between AI and AES randomness is shrinking. My next step is to validate the AI-generated keys using formal NIST randomness tests. NIST randomness tests are the gold standard for randomization. It is the final barrier before these keys can be evaluated against real cryptographic systems.
Make sure to take a look at my graphs:
Note: My bit frequency position showed a near 50/50 split. Most of the positions hover between 0.46 and 0.56.
Note: The entropy distribution of the generated keys is a very strong cluster near 0.999–1.000. I also noticed a small area under 0.98, indicating the randomness.
The fact that my GAN can produce results that are very close to cryptographic-grade randomness suggests that neural networks may soon become viable tools in security and encryption applications. I hope you enjoyed reading and even learnt something. See you next time!
Week 6: From GAN to the Gold Standard
Welcome back to my blog! I’m Victor. Over the last few weeks, I have been analyzing how the randomness of AI-generated keys compares with traditional keys. AI is rapidly changing society. AI-generated keys might be more effective for encryption purposes than traditional methods. This week, I shifted from analyzing randomness to preparing for formal cryptographic randomness validation. My focus is on ensuring that the key data is properly formatted and able to be evaluated by the gold standard for randomness testing.
Those 10,000 GAN-generated 128-bit keys have been turned into a binary format suitable for cryptographic testing. I also cloned the NIST Statistical Test Suite from GitHub. However, during the build process, I encountered an issue: the expected assess binary was missing after compilation. The assess binary is a file that is supposed to be within the general folder for the NIST Randomness tests. I did end up exploring alternative solutions, such as switching to a more reliable fork for a smoother building experience.
Formal randomness testing requires precise data formatting and a stable toolchain. The trouble is that some of these versions are so archaic that they present technical challenges when working on modern systems. The NIST STS is a legacy tool. Looking ahead, I plan to resolve the previous build and compilation issues, so that the toolchain actually is functional on macOS. I still am of the firm belief that the full NIST SP 800-22 test suite must be executed on my GAN-generated keys. Once the tests are complete I can calculate the pass rates from the p-values. My goal is to achieve a pass rate of over 98%, which would indicate strong performance in randomness. In the rare condition that the NIST results indicate certain areas for improvement, I am prepared to retrain the GAN architecture with modified parameters for usage.
I also plan on creating histograms of the p-value distributions and pass/fail summary charts, which are useful for seeing the differences between AI-keys and traditional ones. All of this will help me narrow down the results and support my belief that AI-generated keys are stronger than traditional ones for encryption purposes. I hope you all enjoyed this week’s blog. See you all next week!
Week 7: What NIST Taught Me About Encryption
Welcome back to my blog! This week marks significant progress. I modeled a traditional key schedule (Lai-Massey). It replicated the key schedule from one of my sources “A Proposal for a New Block Encryption Standard”. I used the NIST test and compared it against an entropy-based system in order to highlight the limitations in structure. I then simulated the generation with 25-bit cyclic shifts, as it was done in the original cipher. My “traditional_key” file is where I compiled and ran the NIST Statistical Test, after I had converted the original keys into 10 streams of 100,000 bits each. Doing this made it NIST compatible.
I went through the full journey from input selection -> test selection -> parameter tuning -> results analysis. So, in theory, this all should work. Yet, virtually all of the tests failed, except the Linear Complexity one which returned 10/10. Even for that one, the p-value (value for probability of the extremities of data compared to the original data observed) was 0. There are false positives with this. I need entropy, not patterns. The traditional key schedule is not meant to produce randomness in the case of what the NIST Randomness tests actually are made for. I only got 832 bits from the full Lai-Massey key schedule.
I tested a stream on the digits of π (pi). That was an entropy-based stream and nearly all of the values had succeeded. The NIST STS is working, but traditional keys are not made for it.
NIST randomness and ‘encryption strength’ are two very different things for security. For modern apps, true entropy is essential. I express the belief that these tests have shown that AI-generated/entropy-sourced keys are far better for encryption purposes than traditional keys.
On a lighter note, I have also begun working on a video of a hacker breaking into traditional vs. AI-generated keys. The attacker breaks into the traditional key one because of the statistical predictability. The attacker faces problems with the AI-generated keys, because they pass through the NIST Randomness tests.
In the video around 15 seconds in, the hacker on the left succeeds, and the right one fails. Give me any suggestions of things that I should include in this video, since I have just gotten started.
That’s all for now. Thank you for following along. See you next week!
Source(s) Cited:
Lai, X., & Massey, J. L. (1990). A proposal for a new block encryption standard. In I. B. Damgård (Ed.), Advances in Cryptology — EUROCRYPT’90 (Lecture Notes in Computer Science, Vol. 473, pp. 389–404). Springer. https://doi.org/10.1007/3-540-46877-3_35
Week 8: Refining the Cryptanalysis
Welcome back to my blog, everyone. Traditional keys are like basic locks with numerous predictable patterns. They are quite easy to break through. In contrast, AI-generated keys are far more organic in nature. Now that a clean cryptanalysis pipeline has been built, by outputting 10,000 128-bit binary keys, running a full NIST STS test suite, along with the Chi-Square and Runs Tests, and entropy histograms, my data can now be used for testing cryptographic entropy in general.
I’ve made the GitHub repository more clean and streamlined. We can now see clear structure, many charts, and I have even added quite a few things to the README section. The final visuals have an embedded markdown. Alongside this work, I have deepened my understanding of the Assembly language (especially its x86 variant), CPU architecture, and how the Terminal allows for direct system-level access. Learning how these systems operate at a low level has made me deeply appreciate the mechanisms behind what truly makes data reliable and unreliable. Occasionally, when working with GitHub, a few problems appear with the Terminal, but they have been resolved.
I have also worked on my Literature Review, which takes my results from this project as well as insight from the articles I have chosen, to merge them together in that final paper on how AI-generated keys truly compare to traditional models, both theoretically and empirically. If any of you are interested in cybersecurity, cryptography, cryptanalysis, or even just applying randomness testing with at least some knowledge of Python, come and explore the repository.
GitHub Repository: https://github.com/JustnEye/AI-Random-KeyStudy
Thanks for reading. I will keep you updated on my Literature Review, and my continued developments with testing different key sizes and a multitude of other mechanisms.
Week 9: The Oracle of Entropy
Welcome back to my blog! I have continued my Literature Review and have also reviewed my GitHub repository. However, I have come up with the idea of creating a virtual machine that checks whether a key has truly passed randomness. I call it the ‘Oracle of Entropy’, and it is a useful addition to my project.
It generates binary cryptographic keys using Python, and these keys can be GAN-generated. It converts them into a raw binary format that is suitable for low-level analysis, since the C language is seen by many as “low-level”, meaning that it works far more actively with the memory and hardware architecture compared to higher-level languages, such as Python for instance. The analysis system then analyzes the entropy of each key in C using Shannon entropy, a very efficient way to judge the randomness. After parsing, each key receives symbolic names.
My “oracle of entropy” folder consists of a generator, analyzer, interpreter, interface (between Python and C), keys (that store generated .npy and .bin keys), and outputs. So, the final output is a JSON object that contains the entropy, verdict, symbol, poetic name, timestamp, and the hash value. Out of the maximum entropy of 8.0000, my entropy value of 7.9986 is extremely high. So, the key is very random and cryptographically strong. For security reasons, I will not give out the actual hash value here, but anyone with the hash can verify the key’s identity. Here’s an example output:
{
"entropy": 7.9986,
"verdict": "Sacred",
"symbol": "🜄",
"name": "Silent Tongue",
"timestamp": "2099-07-11 12:36:25",
"sha256": "870bfce9..."
}
The machine treats entropy as an important and poetic process, which I find to be a fascinating addition to this project. I hope you all enjoyed the blog and see you next week!
Week 10: Analysis Underway
When I was working on my final paper, I reviewed the Literature Review section. The Literature Review section of my paper has sources that deal with the role of entropy, AI for security purposes and protecting information, and even how all of this would work in a post-quantum context. The Methodology section describes how I built and trained the GAN, the PyTorch code, the NIST tests, and how exactly I ran the experiments. It is also good to see how exactly these results compare to traditional keys such as AES. The Results section contains the chi-square results and graphs of the AI vs. traditional keys. There will also be a section for the Oracle of Entropy.
Traditional key generation relies on deterministic algorithms that are usually vulnerable to AI attacks, because of their lack of randomness. This project has explored how AI-based solutions can generate high-entropy keys (a lot of randomness) and then see how much better they are compared to traditional methods. I have addressed entropy’s role in the strength of cryptographic methods and whether GANs could be a potential alternative in the post-quantum world.
I have also worked on my results and discussion section. I am also reviewing and visualizing the output data (e.g., the entropy distributions, bit frequency, and p-values (the probability of obtaining test results at least as extreme as the result actually observed)). These results are being integrated into both the paper and the final presentation. Thanks to you all for reading!
Week 12: Concluding Entry
Hello everyone. Thanks for checking out my blog one last time. I gave a great Senior Project Presentation and finished my Paper, and learned a ton along the way. When I set out, I merely wanted to know how AI could handle other malicious forms of AI and ‘bad-faith’ actors in general. Yet, throughout my Senior Project, AI, encryption, and the future of not only online security but also AI in general has become far more clear to me.
The Oracle of Entropy was the crown jewel of my project, and producing it and seeing how it worked was a pleasurable experience. I learned how to bridge the gap between Python and C, as well as how to think in terms of entropy and symbolism. GitHub also was an important layer in my project, as it is the place where my visible files and code can be shown. However, despite all of this good news, there were plenty of moments where I doubted my capabilities and didn’t even want to continue the project, despite my advisor giving me support. There were just so many different parts to integrate together. The effects are that I have become more flexible in mixing concepts together.
The final entropy score of my AI-generated keys was roughly 0.999, and the final score for the Oracle of Entropy keys was roughly 7.99. Both of them showed significant randomness, aligning with my whole hypothesis from the very beginning, that AI-generated keys are in fact, more random compared to traditional methods. I want to make sure that the world is adaptive to the very real emergent threats and issues of the future.
As I leave high school, I see this not as an ending, but a foundation. I now know that I can build things and learn along the way. I appreciate Mr. Sëllström for showing me how AI systems work, checking if there were any issues, and guiding me through the process. Thank you, Mr. Winter for refining my presentation, oratory, and checking with me to see how the wider school community would interpret my research.
Link to Final Presentation: https://docs.google.com/presentation/d/1wYXxR9xeghCeuAV4eQ6jhh3GpSklar6moHCinARX6yo/edit?usp=sharing
But really, thanks to anyone who followed this journey, explored the problems, or just enjoyed the process. I’ll carry these lessons in college and beyond that, and I won’t ever forget how much BASIS gave to me.
There’s still work to be done.
Goodbye for now.
- Victor