protected void engineInit(Key key, AlgorithmParameterSpec params) throws InvalidKeyException, InvalidAlgorithmParameterException { CipherParameters param; if (key == null) { throw new InvalidKeyException("key is null"); } if (key instanceof JCEPBEKey) { JCEPBEKey k = (JCEPBEKey) key; if (k.getParam() != null) { param = k.getParam(); } else if (params instanceof PBEParameterSpec) { param = PBE.Util.makePBEMacParameters(k, params); } else { throw new InvalidAlgorithmParameterException("PBE requires PBE parameters to be set."); } } else if (params instanceof IvParameterSpec) { param = new ParametersWithIV( new KeyParameter(key.getEncoded()), ((IvParameterSpec) params).getIV()); } else if (params == null) { param = new KeyParameter(key.getEncoded()); } else { throw new InvalidAlgorithmParameterException("unknown parameter type."); } macEngine.init(param); }
/** 生成密钥对 */ public static Map<String, String> generateKeyPair() throws Exception { /** RSA算法要求有一个可信任的随机数源 */ SecureRandom sr = new SecureRandom(); /** 为RSA算法创建一个KeyPairGenerator对象 */ KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA"); /** 利用上面的随机数据源初始化这个KeyPairGenerator对象 */ kpg.initialize(KEYSIZE, sr); /** 生成密匙对 */ KeyPair kp = kpg.generateKeyPair(); /** 得到公钥 */ Key publicKey = kp.getPublic(); byte[] publicKeyBytes = publicKey.getEncoded(); String pub = new String(Base64.encodeBase64(publicKeyBytes), ConfigureEncryptAndDecrypt.CHAR_ENCODING); /** 得到私钥 */ Key privateKey = kp.getPrivate(); byte[] privateKeyBytes = privateKey.getEncoded(); String pri = new String(Base64.encodeBase64(privateKeyBytes), ConfigureEncryptAndDecrypt.CHAR_ENCODING); Map<String, String> map = new HashMap<String, String>(); map.put("publicKey", pub); map.put("privateKey", pri); RSAPublicKey rsp = (RSAPublicKey) kp.getPublic(); BigInteger bint = rsp.getModulus(); byte[] b = bint.toByteArray(); byte[] deBase64Value = Base64.encodeBase64(b); String retValue = new String(deBase64Value); map.put("modulus", retValue); return map; }
private static BufferedBlockCipher func_75892_a(boolean par0, Key par1Key) { BufferedBlockCipher var2 = new BufferedBlockCipher(new CFBBlockCipher(new AESFastEngine(), 8)); var2.init( par0, new ParametersWithIV(new KeyParameter(par1Key.getEncoded()), par1Key.getEncoded(), 0, 16)); return var2; }
/** * Converts, if possible, a given key into a key specification. Currently, the following key * specifications are supported: * * <ul> * <li>for McElieceCCA2PublicKey: {@link X509EncodedKeySpec}, {@link McElieceCCA2PublicKeySpec} * <li>for McElieceCCA2PrivateKey: {@link PKCS8EncodedKeySpec}, {@link * McElieceCCA2PrivateKeySpec}. * </ul> * * @param key the key * @param keySpec the key specification * @return the specification of the McEliece CCA2 key * @throws InvalidKeySpecException if the key type or the key specification is not supported. * @see BCMcElieceCCA2PrivateKey * @see McElieceCCA2PrivateKeySpec * @see BCMcElieceCCA2PublicKey * @see McElieceCCA2PublicKeySpec */ public KeySpec getKeySpec(Key key, Class keySpec) throws InvalidKeySpecException { if (key instanceof BCMcElieceCCA2PrivateKey) { if (PKCS8EncodedKeySpec.class.isAssignableFrom(keySpec)) { return new PKCS8EncodedKeySpec(key.getEncoded()); } else if (McElieceCCA2PrivateKeySpec.class.isAssignableFrom(keySpec)) { BCMcElieceCCA2PrivateKey privKey = (BCMcElieceCCA2PrivateKey) key; return new McElieceCCA2PrivateKeySpec( OID, privKey.getN(), privKey.getK(), privKey.getField(), privKey.getGoppaPoly(), privKey.getP(), privKey.getH(), privKey.getQInv()); } } else if (key instanceof BCMcElieceCCA2PublicKey) { if (X509EncodedKeySpec.class.isAssignableFrom(keySpec)) { return new X509EncodedKeySpec(key.getEncoded()); } else if (McElieceCCA2PublicKeySpec.class.isAssignableFrom(keySpec)) { BCMcElieceCCA2PublicKey pubKey = (BCMcElieceCCA2PublicKey) key; return new McElieceCCA2PublicKeySpec(OID, pubKey.getN(), pubKey.getT(), pubKey.getG()); } } else { throw new InvalidKeySpecException("Unsupported key type: " + key.getClass() + "."); } throw new InvalidKeySpecException("Unknown key specification: " + keySpec + "."); }
public static BufferedBlockCipher getCipher(boolean forEncryption, Key shared) { BufferedBlockCipher cip = new BufferedBlockCipher(new CFBBlockCipher(new AESFastEngine(), 8)); cip.init( forEncryption, new ParametersWithIV(new KeyParameter(shared.getEncoded()), shared.getEncoded(), 0, 16)); return cip; }
/** * This method returns a specification for the supplied key. * * <p>The specification will be returned in the form of an object of the type specified by * keySpec. * * @param key - either DSAPrivateKey or DSAPublicKey * @param keySpec - either DSAPrivateKeySpec.class or DSAPublicKeySpec.class * @return either a DSAPrivateKeySpec or a DSAPublicKeySpec * @throws InvalidKeySpecException if "keySpec" is not a specification for DSAPublicKey or * DSAPrivateKey */ protected <T extends KeySpec> T engineGetKeySpec(Key key, Class<T> keySpec) throws InvalidKeySpecException { BigInteger p, q, g, x, y; if (key != null) { if (keySpec == null) { throw new NullPointerException("keySpec == null"); } if (key instanceof DSAPrivateKey) { DSAPrivateKey privateKey = (DSAPrivateKey) key; if (keySpec.equals(DSAPrivateKeySpec.class)) { x = privateKey.getX(); DSAParams params = privateKey.getParams(); p = params.getP(); q = params.getQ(); g = params.getG(); return (T) (new DSAPrivateKeySpec(x, p, q, g)); } if (keySpec.equals(PKCS8EncodedKeySpec.class)) { return (T) (new PKCS8EncodedKeySpec(key.getEncoded())); } throw new InvalidKeySpecException( "'keySpec' is neither DSAPrivateKeySpec nor PKCS8EncodedKeySpec"); } if (key instanceof DSAPublicKey) { DSAPublicKey publicKey = (DSAPublicKey) key; if (keySpec.equals(DSAPublicKeySpec.class)) { y = publicKey.getY(); DSAParams params = publicKey.getParams(); p = params.getP(); q = params.getQ(); g = params.getG(); return (T) (new DSAPublicKeySpec(y, p, q, g)); } if (keySpec.equals(X509EncodedKeySpec.class)) { return (T) (new X509EncodedKeySpec(key.getEncoded())); } throw new InvalidKeySpecException( "'keySpec' is neither DSAPublicKeySpec nor X509EncodedKeySpec"); } } throw new InvalidKeySpecException("'key' is neither DSAPublicKey nor DSAPrivateKey"); }
public static String getPrivateKey(Map<String, Object> keyMap) throws Exception { Key key = (Key) keyMap.get(PRIVATE_KEY); byte[] privateKey = key.getEncoded(); return encryptBASE64(key.getEncoded()); }
/** * This method returns a specification for the supplied key. * * <p>The specification will be returned in the form of an object of the type specified by * keySpec. * * @param key - either DSAPrivateKey or DSAPublicKey * @param keySpec - either DSAPrivateKeySpec.class or DSAPublicKeySpec.class * @return either a DSAPrivateKeySpec or a DSAPublicKeySpec * @throws InvalidKeySpecException if "keySpec" is not a specification for DSAPublicKey or * DSAPrivateKey */ protected <T extends KeySpec> T engineGetKeySpec(Key key, Class<T> keySpec) throws InvalidKeySpecException { BigInteger p, q, g, x, y; if (key != null) { if (keySpec == null) { throw new NullPointerException(Messages.getString("security.19E")); // $NON-NLS-1$ } if (key instanceof DSAPrivateKey) { DSAPrivateKey privateKey = (DSAPrivateKey) key; if (keySpec.equals(DSAPrivateKeySpec.class)) { x = privateKey.getX(); DSAParams params = privateKey.getParams(); p = params.getP(); q = params.getQ(); g = params.getG(); return (T) (new DSAPrivateKeySpec(x, p, q, g)); } if (keySpec.equals(PKCS8EncodedKeySpec.class)) { return (T) (new PKCS8EncodedKeySpec(key.getEncoded())); } throw new InvalidKeySpecException(Messages.getString("security.19C")); // $NON-NLS-1$ } if (key instanceof DSAPublicKey) { DSAPublicKey publicKey = (DSAPublicKey) key; if (keySpec.equals(DSAPublicKeySpec.class)) { y = publicKey.getY(); DSAParams params = publicKey.getParams(); p = params.getP(); q = params.getQ(); g = params.getG(); return (T) (new DSAPublicKeySpec(y, p, q, g)); } if (keySpec.equals(X509EncodedKeySpec.class)) { return (T) (new X509EncodedKeySpec(key.getEncoded())); } throw new InvalidKeySpecException(Messages.getString("security.19D")); // $NON-NLS-1$ } } throw new InvalidKeySpecException(Messages.getString("security.19F")); // $NON-NLS-1$ }
private static BufferedBlockCipher func_75892_a(boolean p_75892_0_, Key p_75892_1_) { BufferedBlockCipher bufferedblockcipher = new BufferedBlockCipher(new CFBBlockCipher(new AESFastEngine(), 8)); bufferedblockcipher.init( p_75892_0_, new ParametersWithIV( new KeyParameter(p_75892_1_.getEncoded()), p_75892_1_.getEncoded(), 0, 16)); return bufferedblockcipher; }
public boolean shareAESkey() { try { Envelope message = null, e = null; // Generate AES key KeyGenerator keyGen = KeyGenerator.getInstance("AES"); AESkey = keyGen.generateKey(); keyGen = KeyGenerator.getInstance("HmacSHA1"); HMACkey = keyGen.generateKey(); byte[] keyBytes = AESkey.getEncoded(); byte[] hashBytes = HMACkey.getEncoded(); System.out.println("AES key generated"); System.out.println("HMAC key generated"); System.out.println("Begin Encryption..."); // Encrypt message w/ provided public key Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); cipher.init(Cipher.ENCRYPT_MODE, pubKey); byte[] cipherBytes = cipher.doFinal(keyBytes); byte[] cipherBytes1 = cipher.doFinal(hashBytes); System.out.println("Encryption Complete"); message = new Envelope("SKEY"); message.addObject(cipherBytes); // Add AESkey to message message.addObject(cipherBytes1); message.addObject(nonce); nonce++; byte[] messageBytes = Envelope.toByteArray(message); output.writeObject(messageBytes); byte[] inCipherBytes = (byte[]) input.readObject(); // Decrypt response cipher = Cipher.getInstance("AES"); cipher.init(Cipher.DECRYPT_MODE, AESkey); byte[] responseBytes = cipher.doFinal(inCipherBytes); Envelope response = Envelope.getEnvelopefromBytes(responseBytes); // If server indicates success, return the member list if (response.getMessage().equals("OK") && (Integer) response.getObjContents().get(0) == nonce) { return true; } else { return false; } } catch (Exception e) { System.err.println("Error: " + e.getMessage()); e.printStackTrace(System.err); return false; } }
protected <T extends KeySpec> T engineGetKeySpec(Key key, Class<T> keySpec) throws InvalidKeySpecException { try { // convert key to one of our keys // this also verifies that the key is a valid RSA key and ensures // that the encoding is X.509/PKCS#8 for public/private keys key = engineTranslateKey(key); } catch (InvalidKeyException e) { throw new InvalidKeySpecException(e); } if (key instanceof RSAPublicKey) { RSAPublicKey rsaKey = (RSAPublicKey) key; if (rsaPublicKeySpecClass.isAssignableFrom(keySpec)) { return keySpec.cast(new RSAPublicKeySpec(rsaKey.getModulus(), rsaKey.getPublicExponent())); } else if (x509KeySpecClass.isAssignableFrom(keySpec)) { return keySpec.cast(new X509EncodedKeySpec(key.getEncoded())); } else { throw new InvalidKeySpecException( "KeySpec must be RSAPublicKeySpec or " + "X509EncodedKeySpec for RSA public keys"); } } else if (key instanceof RSAPrivateKey) { if (pkcs8KeySpecClass.isAssignableFrom(keySpec)) { return keySpec.cast(new PKCS8EncodedKeySpec(key.getEncoded())); } else if (rsaPrivateCrtKeySpecClass.isAssignableFrom(keySpec)) { if (key instanceof RSAPrivateCrtKey) { RSAPrivateCrtKey crtKey = (RSAPrivateCrtKey) key; return keySpec.cast( new RSAPrivateCrtKeySpec( crtKey.getModulus(), crtKey.getPublicExponent(), crtKey.getPrivateExponent(), crtKey.getPrimeP(), crtKey.getPrimeQ(), crtKey.getPrimeExponentP(), crtKey.getPrimeExponentQ(), crtKey.getCrtCoefficient())); } else { throw new InvalidKeySpecException("RSAPrivateCrtKeySpec can only be used with CRT keys"); } } else if (rsaPrivateKeySpecClass.isAssignableFrom(keySpec)) { RSAPrivateKey rsaKey = (RSAPrivateKey) key; return keySpec.cast( new RSAPrivateKeySpec(rsaKey.getModulus(), rsaKey.getPrivateExponent())); } else { throw new InvalidKeySpecException( "KeySpec must be RSAPrivate(Crt)KeySpec or " + "PKCS8EncodedKeySpec for RSA private keys"); } } else { // should not occur, caught in engineTranslateKey() throw new InvalidKeySpecException("Neither public nor private key"); } }
/** * Convert a Key to string encoded as BASE64 * * @param key The key (private or public) * @return A string representation of the key */ public static String getKeyAsString(Key key) { // Get the bytes of the key byte[] keyBytes = key.getEncoded(); // Convert key to BASE64 encoded string BASE64Encoder b64 = new BASE64Encoder(); return b64.encode(keyBytes); }
/** * Returns the key size of the given key object. * * @param key the key object. * @return the key size of the given key object. * @exception InvalidKeyException if <code>key</code> is invalid. */ protected int engineGetKeySize(Key key) throws InvalidKeyException { byte[] encoded = key.getEncoded(); if (encoded.length != 8) { throw new InvalidKeyException("Invalid key length: " + encoded.length + " bytes"); } return 56; }
@Override public String toString() { if (null == _nodeKey) { return "NodeKey for node: " + _nodeName + " Stored at: " + _storedNodeKeyName + " Stored ID: " + DataUtils.printHexBytes(_storedNodeKeyID) + " Key: null" + " Key id: null"; } // not great to print out keys, but nec for debugging return "NodeKey for node: " + _nodeName + " Stored at: " + _storedNodeKeyName + " Stored ID: " + DataUtils.printHexBytes(_storedNodeKeyID) + " Key: " + DataUtils.printHexBytes(_nodeKey.getEncoded()) + " Key id: " + DataUtils.printHexBytes(WrappedKey.wrappingKeyIdentifier(_nodeKey)); }
public String createKey() throws NoSuchAlgorithmException, NoSuchProviderException { KeyGenerator keygen = KeyGenerator.getInstance("AES", "BC"); keygen.init(256); Key key = keygen.generateKey(); return Base64.encodeBase64String(key.getEncoded()); }
@Override public void storeKey(Key key) throws KeyStoringException { Path keyPath = FileSystemService.getUserRapidMinerDir().toPath().resolve(DEFAULTKEY_FILE_NAME); try { KeyGeneratorTool.storeKey(key.getEncoded(), keyPath); } catch (IOException e) { throw new KeyStoringException("Could not store new cipher key", e); } }
@Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((_nodeKey == null) ? 0 : Arrays.hashCode(_nodeKey.getEncoded())); result = prime * result + ((_nodeName == null) ? 0 : _nodeName.hashCode()); result = prime * result + Arrays.hashCode(_storedNodeKeyID); result = prime * result + ((_storedNodeKeyName == null) ? 0 : _storedNodeKeyName.hashCode()); return result; }
@Override protected byte[] engineWrap(Key key) throws IllegalBlockSizeException, InvalidKeyException { try { byte[] encoded = key.getEncoded(); return engineDoFinal(encoded, 0, encoded.length); } catch (BadPaddingException e) { IllegalBlockSizeException newE = new IllegalBlockSizeException(); newE.initCause(e); throw newE; } }
/** * 张纪豪添加 * * @param len * @param password * @return */ public static String generateKey(int len, String password) { try { KeyGenerator keyGen = KeyGenerator.getInstance("AES"); keyGen.init(len); keyGen.init(128, new SecureRandom(password.getBytes())); Key key = keyGen.generateKey(); return Strings.toHexString(key.getEncoded()); } catch (Exception e) { return null; } }
public static String generateKey(int len) { try { KeyGenerator keyGen = KeyGenerator.getInstance("AES"); keyGen.init(len); Key key = keyGen.generateKey(); // System.out.println(key.getEncoded()); return Strings.toHexString(key.getEncoded()); } catch (Exception e) { return null; } }
protected void engineInit( int paramInt, Key paramKey, AlgorithmParameterSpec paramAlgorithmParameterSpec, SecureRandom paramSecureRandom) { Object localObject; if ((paramKey instanceof BCPBEKey)) { paramKey = (BCPBEKey) paramKey; if ((paramAlgorithmParameterSpec instanceof PBEParameterSpec)) { localObject = PBE.Util.ˊ(paramKey, paramAlgorithmParameterSpec, this.aXL.iG()); } else if (paramKey.nU() != null) { localObject = paramKey.nU(); } else { throw new InvalidAlgorithmParameterException("PBE requires PBE parameters to be set."); } } else { localObject = new KeyParameter(paramKey.getEncoded()); } paramKey = (Key) localObject; if ((paramAlgorithmParameterSpec instanceof IvParameterSpec)) { paramKey = new ParametersWithIV( (CipherParameters) localObject, ((IvParameterSpec) paramAlgorithmParameterSpec).getIV()); } paramAlgorithmParameterSpec = paramKey; if ((paramKey instanceof KeyParameter)) { paramAlgorithmParameterSpec = paramKey; if (this.aYU != 0) { this.iv = new byte[this.aYU]; paramSecureRandom.nextBytes(this.iv); paramAlgorithmParameterSpec = new ParametersWithIV(paramKey, this.iv); } } paramKey = paramAlgorithmParameterSpec; if (paramSecureRandom != null) { paramKey = new ParametersWithRandom(paramAlgorithmParameterSpec, paramSecureRandom); } switch (paramInt) { default: break; case 3: this.aXL.ˊ(true, paramKey); return; case 4: this.aXL.ˊ(false, paramKey); return; case 1: case 2: throw new IllegalArgumentException("engine only valid for wrapping"); } System.out.println("eeek!"); }
/** * Wrapping allows to mask/encapsulate/protect the key used Create another key, use a cipher with * it and {@link Cipher#WRAP_MODE} and wrap the original key To unwrap, use a cipher with {@link * Cipher#UNWRAP_MODE} */ static void wrapUnwrapKey() throws Exception { // create a key to wrap KeyGenerator generator = KeyGenerator.getInstance("AES"); generator.init(128); Key keyToBeWrapped = generator.generateKey(); System.out.println("input : " + Utils.toHex(keyToBeWrapped.getEncoded())); // create a wrapper and do the wrapping Cipher cipher = Cipher.getInstance("AESWrap"); KeyGenerator keyGenerator = KeyGenerator.getInstance("AES"); keyGenerator.init(128); Key wrapKey = keyGenerator.generateKey(); cipher.init(Cipher.WRAP_MODE, wrapKey); byte[] wrappedKey = cipher.wrap(keyToBeWrapped); System.out.println("wrapped : " + Utils.toHex(wrappedKey)); // unwrap the wrapped key cipher.init(Cipher.UNWRAP_MODE, wrapKey); Key key = cipher.unwrap(wrappedKey, "AES", Cipher.SECRET_KEY); System.out.println("unwrapped: " + Utils.toHex(key.getEncoded())); }
protected byte[] engineWrap(Key key) throws IllegalBlockSizeException, InvalidKeyException { byte[] encoded = key.getEncoded(); if (encoded == null) { throw new InvalidKeyException("Cannot wrap key, null encoding."); } try { return engineDoFinal(encoded, 0, encoded.length); } catch (BadPaddingException e) { throw new IllegalBlockSizeException(e.getMessage()); } }
@Test(timeout = 30000) public void testKeyStoreKeyProviderWithPassword() throws Exception { KeyProvider provider = new KeyStoreKeyProvider(); provider.init("jceks://" + storeFile.toURI().getPath() + "?password=" + PASSWORD); Key key = provider.getKey(ALIAS); assertNotNull(key); byte[] keyBytes = key.getEncoded(); assertEquals(keyBytes.length, KEY.length); for (int i = 0; i < KEY.length; i++) { assertEquals(keyBytes[i], KEY[i]); } }
public static byte[] genarateRandomKey() { KeyGenerator keygen = null; try { keygen = KeyGenerator.getInstance(ConfigureEncryptAndDecrypt.AES_ALGORITHM); } catch (NoSuchAlgorithmException e) { throw new RuntimeException(" genarateRandomKey fail!", e); } SecureRandom random = new SecureRandom(); keygen.init(random); Key key = keygen.generateKey(); return key.getEncoded(); }
@Kroll.method public KrollDict generateKeyPair() { // generate key pair // KrollDict arg = new KrollDict(); try { KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA"); kpg.initialize(1024); KeyPair kp = kpg.genKeyPair(); publicKey = kp.getPublic(); privateKey = kp.getPrivate(); arg.put("privateKey", Base64.encodeToString(privateKey.getEncoded(), Base64.NO_WRAP)); arg.put("publicKey", Base64.encodeToString(publicKey.getEncoded(), Base64.NO_WRAP)); } catch (Exception e) { Log.e(TAG, "RSA key pair error"); } return arg; }
/** * Encrypt the MAC key using the provided shared secret. * * @param macKey MAC key to encrypt * @param sharedSecret shared secret used to encrypt MAC key * @return encrypted MAC Key */ private static SecretKey macKeyEncryption(Key macKey, SecretKey sharedSecret) { try { MessageDigest messageDigest = MessageDigest.getInstance(sharedSecret.getAlgorithm()); byte[] digestedSecret = messageDigest.digest(sharedSecret.getEncoded()); byte[] encrypted = xor(macKey.getEncoded(), digestedSecret); return new SecretKeySpec(encrypted, macKey.getAlgorithm()); } catch (NoSuchAlgorithmException e) { log.error("unable to encrypt MAC key: {}", e.getMessage()); } return null; }
protected KeySpec engineGetKeySpec(Key key, Class spec) throws InvalidKeySpecException { if (spec.isAssignableFrom(PKCS8EncodedKeySpec.class) && key.getFormat().equals("PKCS#8")) { return new PKCS8EncodedKeySpec(key.getEncoded()); } else if (spec.isAssignableFrom(X509EncodedKeySpec.class) && key.getFormat().equals("X.509")) { return new X509EncodedKeySpec(key.getEncoded()); } else if (spec.isAssignableFrom(RSAPublicKeySpec.class) && key instanceof RSAPublicKey) { RSAPublicKey k = (RSAPublicKey) key; return new RSAPublicKeySpec(k.getModulus(), k.getPublicExponent()); } else if (spec.isAssignableFrom(RSAPrivateKeySpec.class) && key instanceof RSAPrivateKey) { RSAPrivateKey k = (RSAPrivateKey) key; return new RSAPrivateKeySpec(k.getModulus(), k.getPrivateExponent()); } else if (spec.isAssignableFrom(RSAPrivateCrtKeySpec.class) && key instanceof RSAPrivateCrtKey) { RSAPrivateCrtKey k = (RSAPrivateCrtKey) key; return new RSAPrivateCrtKeySpec( k.getModulus(), k.getPublicExponent(), k.getPrivateExponent(), k.getPrimeP(), k.getPrimeQ(), k.getPrimeExponentP(), k.getPrimeExponentQ(), k.getCrtCoefficient()); } else if (spec.isAssignableFrom(DHPrivateKeySpec.class) && key instanceof DHPrivateKey) { DHPrivateKey k = (DHPrivateKey) key; return new DHPrivateKeySpec(k.getX(), k.getParams().getP(), k.getParams().getG()); } else if (spec.isAssignableFrom(DHPublicKeySpec.class) && key instanceof DHPublicKey) { DHPublicKey k = (DHPublicKey) key; return new DHPublicKeySpec(k.getY(), k.getParams().getP(), k.getParams().getG()); } throw new RuntimeException("not implemented yet " + key + " " + spec); }
byte[] getPublicKeyEncoded() { try { // generate a key pair SecureRandom random = new SecureRandom(); KeyPairGenerator generator = KeyPairGenerator.getInstance(ASYM_KEY_TYPE); generator.initialize(ASYM_KEY_SIZE, random); _serverKeyPair = generator.generateKeyPair(); Key pubKey = _serverKeyPair.getPublic(); return pubKey.getEncoded(); } catch (Exception e) { e.printStackTrace(); } return null; }
/** Test that key1 (reference key) and key2 (key to be tested) are equivalent */ private static void testKey(Key key1, Key key2) throws Exception { if (key2.getAlgorithm().equals("EC") == false) { throw new Exception("Algorithm not EC"); } if (key1 instanceof PublicKey) { if (key2.getFormat().equals("X.509") == false) { throw new Exception("Format not X.509"); } } else if (key1 instanceof PrivateKey) { if (key2.getFormat().equals("PKCS#8") == false) { throw new Exception("Format not PKCS#8"); } } if (key1.equals(key2) == false) { System.out.println("key1: " + key1); System.out.println("key2: " + key2); System.out.println("enc1: " + toString(key1.getEncoded())); System.out.println("enc2: " + toString(key2.getEncoded())); throw new Exception("Keys not equal"); } if (Arrays.equals(key1.getEncoded(), key2.getEncoded()) == false) { throw new Exception("Encodings not equal"); } }