gistfile1.java
The private key is created from a secure random number generator, or derived from a seed value (that is created by a secure random number generator). The public key is created from the private key (in Elliptic Curve Cryptography), and the address is the cryptographic hash of that public key (with potentially some other data, like network ID and checksum, to prevent mistyping). First, create the key pair: sn -k keypair.snk Next, extract the public key from the key pair and copy it to a separate file: sn -p keypair.snk public.snk Once you create the key pair, you must put the file where the strong name signing tools can find it.
importjava.security.KeyPairGenerator; |
importjava.security.KeyPair; |
importjava.security.PrivateKey; |
importjava.security.PublicKey; |
importjava.security.KeyFactory; |
importjava.security.spec.EncodedKeySpec; |
importjava.security.spec.PKCS8EncodedKeySpec; |
importjava.security.spec.X509EncodedKeySpec; |
importjava.security.spec.InvalidKeySpecException; |
importjava.security.NoSuchAlgorithmException; |
importcom.sun.jersey.core.util.Base64; |
publicclassGeneratePublicPrivateKeys { |
privatestaticvoidgenerateKeys(StringkeyAlgorithm, intnumBits) { |
try { |
// Get the public/private key pair |
KeyPairGenerator keyGen =KeyPairGenerator.getInstance(keyAlgorithm); |
keyGen.initialize(numBits); |
KeyPair keyPair = keyGen.genKeyPair(); |
PrivateKey privateKey = keyPair.getPrivate(); |
PublicKey publicKey = keyPair.getPublic(); |
System.out.println('n'+'Generating key/value pair using '+ privateKey.getAlgorithm() +' algorithm'); |
// Get the bytes of the public and private keys |
byte[] privateKeyBytes = privateKey.getEncoded(); |
byte[] publicKeyBytes = publicKey.getEncoded(); |
// Get the formats of the encoded bytes |
String formatPrivate = privateKey.getFormat(); // PKCS#8 |
String formatPublic = publicKey.getFormat(); // X.509 |
System.out.println('Private Key : '+Base64.encode(String.valueOf(privateKeyBytes))); |
System.out.println('Public Key : '+Base64.encode(String.valueOf(publicKeyBytes))); |
// The bytes can be converted back to public and private key objects |
KeyFactory keyFactory =KeyFactory.getInstance(keyAlgorithm); |
EncodedKeySpec privateKeySpec =newPKCS8EncodedKeySpec(privateKeyBytes); |
PrivateKey privateKey2 = keyFactory.generatePrivate(privateKeySpec); |
EncodedKeySpec publicKeySpec =newX509EncodedKeySpec(publicKeyBytes); |
PublicKey publicKey2 = keyFactory.generatePublic(publicKeySpec); |
// The original and new keys are the same |
System.out.println(' Are both private keys equal? '+ privateKey.equals(privateKey2)); |
System.out.println(' Are both public keys equal? '+ publicKey.equals(publicKey2)); |
} catch (InvalidKeySpecException specException) { |
System.out.println('Exception'); |
System.out.println('Invalid Key Spec Exception'); |
} catch (NoSuchAlgorithmException e) { |
System.out.println('Exception'); |
System.out.println('No such algorithm: '+ keyAlgorithm); |
} |
} |
publicstaticvoidmain(String[] args) { |
// Generate a 1024-bit Digital Signature Algorithm (DSA) key pair |
generateKeys('DSA', 1024); |
// Generate a 576-bit DH key pair |
generateKeys('DH', 576); |
// Generate a 1024-bit RSA key pair |
generateKeys('RSA', 1024); |
} |
} |
commented Mar 14, 2018
Public Private Key Encryption
Hi You post is interestnig , is there away I can create a privatre key instance via a signature given stiring? I have pub/private keys generated already KeyPairGenerator keyPairGenerator is going to createa key pair, but in my case I alrady have it and then further want to use them for signign. e.g //ecdsaSign.initSign(keyPair.getPrivate()); byte[] pkInfo = '51114cac71a9575bc1b39104d176a39d81bd1a705b9a1ad32efd2222f13e59ad'.getBytes(); // PrivateKey pvtKey = DSAPrivateKey <<<<< create a private key here via above string. instead of keyPair created above. ecdsaSign.initSign(pvtKey); //byte[] publicKeyBytes = keyPair.getPublic().getEncoded(); byte[] publicKeyBytes = '025fe2d166a5a8ff005eb0c799a474174f5d061de266438c69d36c2032c6bff51a'.getBytes(); |
Sign up for freeto join this conversation on GitHub. Already have an account? Sign in to comment
A lost SSH public-key or a web service generates an SSH key but does not provide the public-key part to you. What to do now? There is a solution for this situation.
When you have an SSH key you need the public key to setup SSH passwordless login with SSH-key. But if you have lost the public key part but still have the private key, there is a way to regenerate the key.
With the public key missing, the following command will show you that there is no public key for this SSH key.
The -l option instructs to show the fingerprint in the public key while the -f option specifies the file of the key to list the fingerprint for.
To generate the missing public key again from the private key, the following command will generate the public key of the private key provided with the -f option.
The -y option will read a private SSH key file and prints an SSH public key to stdout. The public key part is redirected to the file with the same name as the private key but with the .pub file extension. If the key has a password set, the password will be required to generate the public key.
To check the details of the generated public key execute the following command as shown above.
Git Generate Public Private Key
The output of this command shows the key size as the first column, the fingerprint as the second column and after the file name, the type is shown in brackets. In the example above, a 4096 bit RSA key.
Read more of my posts on my blog at http://blog.tinned-software.net/.