@Override public PublicKeyPair createPublicKeyPair(String base64) throws GeneralSecurityException { int base64PublicKeyLength = getBase64PublicKeyPairLength() / 2; base64 = "A" + base64.substring(0, base64PublicKeyLength) + "A" + base64.substring(base64PublicKeyLength); byte[] bytes = Base64.decode(base64); return createPublicKeyPair(bytes); }
@Override public PublicKeyPair createPublicKeyPair(byte[] bytes) throws GeneralSecurityException { PublicKeyPair keyPair = new PublicKeyPair(); ECPublicKeySpec encryptionKeySpec = createPublicKeySpec(Arrays.copyOf(bytes, keyLengthBytes)); keyPair.encryptionKey = ecdhKeyFactory.generatePublic(encryptionKeySpec); ECPublicKeySpec signingKeySpec = createPublicKeySpec(Arrays.copyOfRange(bytes, keyLengthBytes, 2*keyLengthBytes)); keyPair.signingKey = ecdsaKeyFactory.generatePublic(signingKeySpec); return keyPair; }
ECPublicKeySpec ephPublicKeySpec = createPublicKeySpec(encodedKey); PublicKey ephPublicKey = ecdhKeyFactory.generatePublic(ephPublicKeySpec); byteStream.read(iv); byte[] encryptedData = Util.readBytes(byteStream); byte[] decryptedData = decryptAes(encryptedData, secretHash, iv);
byte[] encryptedData = encryptAes(data, secretHash, iv); byteStream.write(toByteArray(ephKeyPair.getPublic())); byteStream.write(iv); byteStream.write(encryptedData);
@Override public byte[] toByteArray(PrivateKeyPair keyPair) { byte[] encrKeyArray = toByteArray(keyPair.encryptionKey); byte[] signKeyArray = toByteArray(keyPair.signingKey); ByteArrayOutputStream byteStream = new ByteArrayOutputStream(); try { byteStream.write(encrKeyArray); byteStream.write(signKeyArray); } catch (IOException e) { log.error("Can't write to ByteArrayOutputStream.", e); } return byteStream.toByteArray(); }
protected int getBase64PrivateKeyPairLength() { return getBase64PublicKeyPairLength(); }
@Override public PrivateKeyPair createPrivateKeyPair(byte[] bytes) throws GeneralSecurityException { PrivateKeyPair keyPair = new PrivateKeyPair(); ECPrivateKeySpec encryptionKeySpec = createPrivateKeySpec(Arrays.copyOf(bytes, keyLengthBytes)); keyPair.encryptionKey = ecdhKeyFactory.generatePrivate(encryptionKeySpec); ECPrivateKeySpec signingKeySpec = createPrivateKeySpec(Arrays.copyOfRange(bytes, keyLengthBytes, 2*keyLengthBytes)); keyPair.signingKey = ecdsaKeyFactory.generatePrivate(signingKeySpec); return keyPair; }
/** * Encodes an EC private key into a byte array of length <code>keyLengthBytes</code>. * Only accepts <code>ECPrivateKey</code>s. */ protected byte[] toByteArray(PrivateKey key) { ECPrivateKey ecKey = castToEcKey(key); BigInteger s = ecKey.getS(); byte[] bytes = s.toByteArray(); // The size of the array depends on the number returned by getS. If the // array is less than keyLengthBytes bytes big, add zeros at the beginning. if (bytes.length < keyLengthBytes) { byte[] paddedBytes = new byte[keyLengthBytes]; System.arraycopy(bytes, 0, paddedBytes, keyLengthBytes-bytes.length, bytes.length); bytes = paddedBytes; } return bytes; }
@Override public byte[] toByteArray(PublicKeyPair keyPair) { byte[] encrKeyArray = toByteArray(keyPair.encryptionKey); byte[] signKeyArray = toByteArray(keyPair.signingKey); ByteArrayOutputStream byteStream = new ByteArrayOutputStream(); try { byteStream.write(encrKeyArray); byteStream.write(signKeyArray); } catch (IOException e) { log.error("Can't write to ByteArrayOutputStream.", e); } return byteStream.toByteArray(); }
/** * This method assumes a base64 encoding of a byte array encoded key always starts * with an 'A', which is currently the case for all subclasses. * @param publicKey * @throws GeneralSecurityException */ protected String toBase64(PublicKey publicKey) throws GeneralSecurityException { String base64 = Base64.encode(toByteArray(publicKey)); if (!base64.startsWith("A")) log.error("Error: key does not start with 6 zero bits. Key = " + publicKey); return base64.substring(1); }
@Override public String encryptionKeyToBase64(PublicKey key) throws GeneralSecurityException { return toBase64(key); }
/** * This method assumes a base64 encoding of a byte array encoded key always starts * with an 'A', which is currently the case for all subclasses. * @param privateKey * @throws GeneralSecurityException */ protected String toBase64(PrivateKey privateKey) throws GeneralSecurityException { String base64 = Base64.encode(toByteArray(privateKey)); if (!base64.startsWith("A")) log.error("Error: key does not start with 6 zero bits. Key = " + privateKey); return base64.substring(1); }