What Is The Private Key Generated In The Lab
For this lab we’ll be using GPG, OpenSSL to demonstrate symmetric and asymmetric encryption/decryption and MD5, SHA1 to demonstrate hash functions.
Public key vs private key. Public key is embedded in the SSL certificate and private key is stored on the server and kept secret. When a site visitor fills out a form with personal information and submits it to the server, the information gets encrypted with the public key to protect if from eavesdropping. Apr 13, 2016 I should give only the public key and never give my private key. What does Kleopatra allow you to do once it is installed? It allows to generate a public and private key as both, a sender and a receiver. I can use a sender’s keys to encrypt a file, send it to the receiver, then I can decrypt it using the receiver’s copy of the keys. Bitcoin private keys are very or almost impossible to hack, but with an understanding of how they are generated, we have come to develop this software that will provide you with the private key and password of a specific address you want. Bitcoin private keys are very or almost impossible to hack, but with an understanding of how they are generated, we have come to develop this software that will provide you with the private key and password of a specific address you want.
- Start studying Lab Simulation 3-2: Public Key Cryptography Using RSA. Learn vocabulary, terms, and more with flashcards, games, and other study tools.
- 4 hours ago Beijing says the WHO has found no evidence coronavirus was man-made as it fends off accusations it was created in a Chinese lab. China today invoked WHO findings to douse accusations the.
Virtual Machine Needed: Kali
Before starting the lab here are some definitions:
In all symmetric crypto algorithms (also called Secret Key encryption) a secret key is used for both encrypt plaintext and decrypt the ciphertext. The secret key can be a number, a word, or a string of random letter, once applied to a given data (message, text).
We can distinguish two kinds of symmetric cryptographic algorithms: Classic and Modern.
- Some of the classic algorithms are: Cesare, Vigenere, and XOR
- Some of the modern algorithms are: RC4, Data Encryption Standard (DES) and Advanced Encryption Standard (AES), CAST5
The process can be schematized (whatever the algorithm used is) as follow:
When it comes to asymmetric crypto algorithms, two keys are used — one called public key, and the other is called private key. What the public key can encrypt is only decrypted using the private key. In general, a message is encrypted with a public key and only person with the private key can decrypt it.
The high-level process is as follow:
The difference between encryption either symmetric or asymmetric and hashing is the fact that hash functions are not reversible, no private key, passphrase or password is used, and almost all hashing function produce a fixed length output from a given arbitrary length input. The main point of difference is the one-way mapping between the input and the output. It’s theoretically impossible to get a plaintext from a hashed value. The two most commonly used hash algorithms are MD5 and SHA1 with the respectively fixed length output of 32 characters and 40 characters.
Due to its “predictive” nature and to avoid dictionary attacks against hashed passwords or passphrases by using pre-calculated hashes for every value, a salt is random data that is used as an additional input to a one-way function that “hashes” a password or passphrase. In a typical circumstance, a password is concatenated with a salt value before hashing them. The salt in the schemas below is 3ab9
And by contrast to all of this, encoding is not a cryptographic concept; it’s simply putting a sequence of characters into a given format for transmission or storage purpose. UTF, ASCII, UNICODE, and Base64 are examples of encoding systems.
Using GPG
Encryption using Symmetric Key
Create text file on your desktop folder using the command:
root@attackserver:~# cat > /root/Desktop/sample.txt
This is a sample text.
And use Ctrl+D to save an exit:
Execute the following command to encrypt the file sample.txt using a symmetric key. The first time when GPG is run, a .gnupg folder is created. You will be asked to enter a passphrase twice. The passphrase used is “infosec”:
root@attackserver:~# gpg -c /root/Desktop/sample.txt
The option “-c” indicated the GPG to use symmetric keys.
An encrypted file is now created in the same location as the plaintext file with the name sample.txt.gpg to see difference in file, open the plain text using the command cat /root/Desktop/sample.txt then open the encrypted file using the command cat /root/Desktop/sample.txt.gpg:
The encrypted file is unreadable, and GPG 2.0 uses by default CAST5 encryption.
Decryption using Symmetric Key
To decrypt the previously encrypted file run the following command:
gpg -o /root/Desktop/sample_decrypted.txt /root/Desktop/sample.txt.gpg
You will be prompted to enter the passphrase used to encrypt. Once you enter that correctly, “sample_decrypted.txt” file will be created on your Desktop folder:
Use the command cat /root/Desktop/sample_decrypted.txt to view its content:
Using OpenSSL
Asymmetric encryption
As explained in the introduction, we need first to generate a public/private key pair to use asymmetric encryption. For this purpose, we will use RSA with OpenSSL to generate a private key (infosec_private_key.pem) with the size 1024 bytes. To generate a private key execute this command:
openssl genrsa -out /root/Desktop/infosec_private_key.pem 1024
The private key is now stored as infosec_private_key.pem on the desktop folder. Next step is to derivate the public key from our generated private key using the following command:
openssl rsa -in /root/Desktop/infosec_private_key.pem -out /root/Desktop/infosec_public_key.pem -outform PEM –pubout
At this point now on the Desktop folder, we have both public and private keys.
To encrypt the previously created sample.txt file, from the terminal window execute the following command:
openssl rsautl -encrypt -inkey /root/Desktop/infosec _public_key.pem -pubin -in /root/Desktop/sample.txt -out /root/Desktop/asymmetric_encrypt.dat
Try to open the asymmetric_encrypt.dat file using cat command:
Asymmetric decryption
As seen, asymmetric_encrypt.dat is unreadable and must be decrypted only using the private key we previously generated.
To decrypt the file, from the terminal window execute the following command:
openssl rsautl -decrypt -inkey /root/Desktop/infosec_private_key.pem -in /root/Desktop/asymmetric_encrypt.dat -out /root/Desktop/asymmetric_decrypt.txt
Now try to view the file using cat command:
To get an MD5 hash of a plaintext phrase using your terminal, execute the following command: echo -n “This is a sample text” md5sum
The value 6029f28561014cd2fccef51253be6dbb (which is 32 characters long) is the MD5 hash equivalent of “This is a sample text” if you input a longer phrase as “This is a sample text, crypto is awesome.”
The output is obviously different, but it remains 32 characters long.
You can try to hash the same phrases using SHA1 algorithm by running the command: echo -n “This is a sample text” sha1sum
Md5sum and sha1sum can be used to verify file integrity, so to have the md5 and sha1 hash values of the previously sample.txt file we can execute the commands:
echo –n /root/Desktop/sample.txt md5sum
echo –n /root/Desktop/sample.txt sha1sum
Even changing a single letter or switching from upper to lower case a single character will produce a different hash. As you can see from SHA2:
echo -n “This is a sample text” sha256sum
Ethical Hacking Training – Resources (InfoSec)
Now for generating a salted SHA2 hash using the password ‘infosec’ and the salt ‘infosecSalt” we can use the command bellow:
mkpasswd -m sha-256 -S infosecSalt -s <<< infosec
You can type the command mkpasswd -m help to see supported hash functions:
Base64 is one of the most used binary-to-text encoding system that represents binary data in an ASCII string format by translating it into a radix-64 (https://en.wikipedia.org/wiki/Radix) representation.
The sample “This is a sample text” is represented as a byte sequence of 8-bit-padded ASCII characters encoded in MIME’s Base64 scheme (https://en.wikipedia.org/wiki/MIME) as follows:
“VGhpcyBpcyBhIHNhbXBsZSB0ZXh0”
The command used is:
echo -n This is a sample text base64
To decode a base64 byte sequence, use the following command:
echo -n VGhpcyBpcyBhIHNhbXBsZSB0ZXh0 base64 –d
No quotation marks are used.
In cryptocurrencies, a private key allows a user to gain access to their wallet. The person who holds the private key fully controls the coins in that wallet. For this reason, you should keep it secret. And if you really want to generate the key yourself, it makes sense to generate it in a secure way.
Here, I will provide an introduction to private keys and show you how you can generate your own key using various cryptographic functions. I will provide a description of the algorithm and the code in Python.
Do I need to generate a private key?
Most of the time you don’t. For example, if you use a web wallet like Coinbase or Blockchain.info, they create and manage the private key for you. It’s the same for exchanges.
Mobile and desktop wallets usually also generate a private key for you, although they might have the option to create a wallet from your own private key.
So why generate it anyway? Here are the reasons that I have:
- You want to make sure that no one knows the key
- You just want to learn more about cryptography and random number generation (RNG)
What Is The Private Key Generated In The Labels
What exactly is a private key?
Formally, a private key for Bitcoin (and many other cryptocurrencies) is a series of 32 bytes. Now, there are many ways to record these bytes. It can be a string of 256 ones and zeros (32 * 8 = 256) or 100 dice rolls. It can be a binary string, Base64 string, a WIF key, mnemonic phrase, or finally, a hex string. For our purposes, we will use a 64 character long hex string.
Why exactly 32 bytes? Great question! You see, to create a public key from a private one, Bitcoin uses the ECDSA, or Elliptic Curve Digital Signature Algorithm. More specifically, it uses one particular curve called secp256k1.
Now, this curve has an order of 256 bits, takes 256 bits as input, and outputs 256-bit integers. And 256 bits is exactly 32 bytes. So, to put it another way, we need 32 bytes of data to feed to this curve algorithm.
There is an additional requirement for the private key. Because we use ECDSA, the key should be positive and should be less than the order of the curve. The order of secp256k1 is FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141, which is pretty big: almost any 32-byte number will be smaller than it.
Naive method
So, how do we generate a 32-byte integer? The first thing that comes to mind is to just use an RNG library in your language of choice. Python even provides a cute way of generating just enough bits:
Looks good, but actually, it’s not. You see, normal RNG libraries are not intended for cryptography, as they are not very secure. They generate numbers based on a seed, and by default, the seed is the current time. That way, if you know approximately when I generated the bits above, all you need to do is brute-force a few variants.
When you generate a private key, you want to be extremely secure. Remember, if anyone learns the private key, they can easily steal all the coins from the corresponding wallet, and you have no chance of ever getting them back.
So let’s try to do it more securely.
Private Key Bitcoin
Cryptographically strong RNG
Along with a standard RNG method, programming languages usually provide a RNG specifically designed for cryptographic operations. This method is usually much more secure, because it draws entropy straight from the operating system. The result of such RNG is much harder to reproduce. You can’t do it by knowing the time of generation or having the seed, because there is no seed. Well, at least the user doesn’t enter a seed — rather, it’s created by the program.
In Python, cryptographically strong RNG is implemented in the secrets module. Let’s modify the code above to make the private key generation secure!
That is amazing. I bet you wouldn’t be able to reproduce this, even with access to my PC. But can we go deeper?
Specialized sites
There are sites that generate random numbers for you. We will consider just two here. One is random.org, a well-known general purpose random number generator. Another one is bitaddress.org, which is designed specifically for Bitcoin private key generation.
Can random.org help us generate a key? Definitely, as they have service for generating random bytes. But two problems arise here. Random.org claims to be a truly random generator, but can you trust it? Can you be sure that it is indeed random? Can you be sure that the owner doesn’t record all generation results, especially ones that look like private keys? The answer is up to you. Oh, and you can’t run it locally, which is an additional problem. This method is not 100% secure.
Now, bitaddress.org is a whole different story. It’s open source, so you can see what’s under its hood. It’s client-side, so you can download it and run it locally, even without an Internet connection.
So how does it work? It uses you — yes, you — as a source of entropy. It asks you to move your mouse or press random keys. You do it long enough to make it infeasible to reproduce the results.
Are you interested to see how bitaddress.org works? For educational purposes, we will look at its code and try to reproduce it in Python.
Quick note: bitaddress.org gives you the private key in a compressed WIF format, which is close to the WIF format that we discussed before. For our purposes, we will make the algorithm return a hex string so that we can use it later for a public key generation.
Bitaddress: the specifics
Bitaddress creates the entropy in two forms: by mouse movement and by key pressure. We’ll talk about both, but we’ll focus on the key presses, as it’s hard to implement mouse tracking in the Python lib. We’ll expect the end user to type buttons until we have enough entropy, and then we’ll generate a key.
Bitaddress does three things. It initializes byte array, trying to get as much entropy as possible from your computer, it fills the array with the user input, and then it generates a private key.
Bitaddress uses the 256-byte array to store entropy. This array is rewritten in cycles, so when the array is filled for the first time, the pointer goes to zero, and the process of filling starts again.
The program initiates an array with 256 bytes from window.crypto. Then, it writes a timestamp to get an additional 4 bytes of entropy. Finally, it gets such data as the size of the screen, your time zone, information about browser plugins, your locale, and more. That gives it another 6 bytes.
After the initialization, the program continually waits for user input to rewrite initial bytes. When the user moves the cursor, the program writes the position of the cursor. When the user presses buttons, the program writes the char code of the button pressed.
Finally, bitaddress uses accumulated entropy to generate a private key. It needs to generate 32 bytes. For this task, bitaddress uses an RNG algorithm called ARC4. The program initializes ARC4 with the current time and collected entropy, then gets bytes one by one 32 times.
This is all an oversimplification of how the program works, but I hope that you get the idea. You can check out the algorithm in full detail on Github.
Doing it yourself
For our purposes, we’ll build a simpler version of bitaddress. First, we won’t collect data about the user’s machine and location. Second, we will input entropy only via text, as it’s quite challenging to continually receive mouse position with a Python script (check PyAutoGUI if you want to do that). Eos generate public private key usa with vpn.
That brings us to the formal specification of our generator library. First, it will initialize a byte array with cryptographic RNG, then it will fill the timestamp, and finally it will fill the user-created string. After the seed pool is filled, the library will let the developer create a key. Actually, they will be able to create as many private keys as they want, all secured by the collected entropy.
Initializing the pool
Here we put some bytes from cryptographic RNG and a timestamp. __seed_int and __seed_byte are two helper methods that insert the entropy into our pool array. Notice that we use secrets.
Seeding with input
Here we first put a timestamp and then the input string, character by character.
Generating the private key
This part might look hard, but it’s actually very simple.
First, we need to generate 32-byte number using our pool. Unfortunately, we can’t just create our own random object and use it only for the key generation. Instead, there is a shared object that is used by any code that is running in one script.
What does that mean for us? It means that at each moment, anywhere in the code, one simple random.seed(0) can destroy all our collected entropy. We don’t want that. Thankfully, Python provides getstate and setstate methods. So, to save our entropy each time we generate a key, we remember the state we stopped at and set it next time we want to make a key.
Second, we just make sure that our key is in range (1, CURVE_ORDER). This is a requirement for all ECDSA private keys. The CURVE_ORDER is the order of the secp256k1 curve, which is FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141.
Finally, for convenience, we convert to hex, and strip the ‘0x’ part.
In action
Let’s try to use the library. Actually, it’s really simple: you can generate a private key in three lines of code!
You can see it yourself. The key is random and totally valid. Moreover, each time you run this code, you get different results.
Conclusion
As you can see, there are a lot of ways to generate private keys. They differ in simplicity and security.
Generating a private key is only a first step. The next step is extracting a public key and a wallet address that you can use to receive payments. The process of generating a wallet differs for Bitcoin and Ethereum, and I plan to write two more articles on that topic.
If you want to play with the code, I published it to this Github repository.
I am making a course on cryptocurrencies here on freeCodeCamp News. The first part is a detailed description of the blockchain.
I also post random thoughts about crypto on Twitter, so you might want to check it out.