Examples with DHPublicKey javax.crypto.interfaces.DHPublicKey used on opensource projects

Example 16 with DHPublicKey

use of javax.crypto.interfaces.DHPublicKey in project BiglyBT by BiglySoftware.

the class ProtocolDecoderPHE method initCrypto.

protected void initCrypto() throws IOException {
    try {
        KeyPair key_pair = generateDHKeyPair(transport, outbound);
        key_agreement = KeyAgreement.getInstance("DH");
        key_agreement.init(key_pair.getPrivate());
        DHPublicKey dh_public_key = (DHPublicKey) key_pair.getPublic();
        BigInteger dh_y = dh_public_key.getY();
        dh_public_key_bytes = bigIntegerToBytes(dh_y, DH_SIZE_BYTES);
    } catch (Throwable e) {
        throw (new IOException(Debug.getNestedExceptionMessage(e)));
    }
}

Example 17 with DHPublicKey

use of javax.crypto.interfaces.DHPublicKey in project Zom-Android by zom.

the class SerializationUtils method toMessage.

public static AbstractMessage toMessage(String s) throws IOException {
    if (s == null || s.length() <= 1)
        return null;
    if (s.indexOf(SerializationConstants.HEAD) != 0 || s.length() <= SerializationConstants.HEAD.length()) {
        // Try to detect whitespace tag.
        final Matcher matcher = patternWhitespace.matcher(s);
        boolean v1 = false;
        boolean v2 = false;
        while (matcher.find()) {
            if (!v1 && matcher.start(2) > -1)
                v1 = true;
            if (!v2 && matcher.start(3) > -1)
                v2 = true;
            if (v1 && v2)
                break;
        }
        String cleanText = matcher.replaceAll("");
        List<Integer> versions;
        if (v1 && v2) {
            versions = new Vector<Integer>(2);
            versions.add(0, 1);
            versions.add(0, 2);
        } else if (v1) {
            versions = new Vector<Integer>(1);
            versions.add(0, 1);
        } else if (v2) {
            versions = new Vector<Integer>(1);
            versions.add(2);
        } else
            versions = null;
        return new PlainTextMessage(versions, cleanText);
    } else {
        char contentType = s.charAt(SerializationConstants.HEAD.length());
        String content = s.substring(SerializationConstants.HEAD.length() + 1);
        switch(contentType) {
            case SerializationConstants.HEAD_ENCODED:
                ByteArrayInputStream bin = new ByteArrayInputStream(Base64.decode(content, Base64.NO_WRAP));
                OtrInputStream otr = new OtrInputStream(bin);
                // We have an encoded message.
                int protocolVersion = otr.readShort();
                int messageType = otr.readByte();
                switch(messageType) {
                    case AbstractEncodedMessage.MESSAGE_DATA:
                        int flags = otr.readByte();
                        int senderKeyID = otr.readInt();
                        int recipientKeyID = otr.readInt();
                        DHPublicKey nextDH = otr.readDHPublicKey();
                        byte[] ctr = otr.readCtr();
                        byte[] encryptedMessage = otr.readData();
                        byte[] mac = otr.readMac();
                        byte[] oldMacKeys = otr.readMac();
                        return new DataMessage(protocolVersion, flags, senderKeyID, recipientKeyID, nextDH, ctr, encryptedMessage, mac, oldMacKeys);
                    case AbstractEncodedMessage.MESSAGE_DH_COMMIT:
                        byte[] dhPublicKeyEncrypted = otr.readData();
                        byte[] dhPublicKeyHash = otr.readData();
                        return new DHCommitMessage(protocolVersion, dhPublicKeyHash, dhPublicKeyEncrypted);
                    case AbstractEncodedMessage.MESSAGE_DHKEY:
                        DHPublicKey dhPublicKey = otr.readDHPublicKey();
                        return new DHKeyMessage(protocolVersion, dhPublicKey);
                    case AbstractEncodedMessage.MESSAGE_REVEALSIG:
                        {
                            byte[] revealedKey = otr.readData();
                            byte[] xEncrypted = otr.readData();
                            byte[] xEncryptedMac = otr.readMac();
                            return new RevealSignatureMessage(protocolVersion, xEncrypted, xEncryptedMac, revealedKey);
                        }
                    case AbstractEncodedMessage.MESSAGE_SIGNATURE:
                        {
                            byte[] xEncryted = otr.readData();
                            byte[] xEncryptedMac = otr.readMac();
                            return new SignatureMessage(protocolVersion, xEncryted, xEncryptedMac);
                        }
                    default:
                        throw new IOException("Illegal message type.");
                }
            case SerializationConstants.HEAD_MESSAGE:
                return new ErrorMessage(AbstractMessage.MESSAGE_ERROR, content);
            case SerializationConstants.HEAD_QUERY_V:
            case SerializationConstants.HEAD_QUERY_Q:
                List<Integer> versions = new Vector<Integer>();
                String versionString = null;
                if (SerializationConstants.HEAD_QUERY_Q == contentType) {
                    versions.add(1);
                    if (content.charAt(0) == 'v') {
                        versionString = content.substring(1, content.indexOf('?'));
                    }
                } else if (SerializationConstants.HEAD_QUERY_V == contentType) {
                    versionString = content.substring(0, content.indexOf('?'));
                }
                if (versionString != null) {
                    StringReader sr = new StringReader(versionString);
                    int c;
                    while ((c = sr.read()) != -1) if (!versions.contains(c))
                        versions.add(Integer.parseInt(String.valueOf((char) c)));
                }
                QueryMessage query = new QueryMessage(versions);
                return query;
            default:
                throw new IOException("Unknown message type.");
        }
    }
}

Example 18 with DHPublicKey

use of javax.crypto.interfaces.DHPublicKey in project Zom-Android by zom.

the class OtrCryptoEngineImpl method generateDHKeyPair.

public KeyPair generateDHKeyPair() throws OtrCryptoException {
    // Generate a AsymmetricCipherKeyPair using BC.
    DHParameters dhParams = new DHParameters(MODULUS, GENERATOR, null, DH_PRIVATE_KEY_MINIMUM_BIT_LENGTH);
    DHKeyGenerationParameters params = new DHKeyGenerationParameters(new SecureRandom(), dhParams);
    DHKeyPairGenerator kpGen = new DHKeyPairGenerator();
    kpGen.init(params);
    AsymmetricCipherKeyPair pair = kpGen.generateKeyPair();
    // Convert this AsymmetricCipherKeyPair to a standard JCE KeyPair.
    DHPublicKeyParameters pub = (DHPublicKeyParameters) pair.getPublic();
    DHPrivateKeyParameters priv = (DHPrivateKeyParameters) pair.getPrivate();
    try {
        KeyFactory keyFac = KeyFactory.getInstance("DH");
        DHPublicKeySpec pubKeySpecs = new DHPublicKeySpec(pub.getY(), MODULUS, GENERATOR);
        DHPublicKey pubKey = (DHPublicKey) keyFac.generatePublic(pubKeySpecs);
        DHParameters dhParameters = priv.getParameters();
        DHPrivateKeySpec privKeySpecs = new DHPrivateKeySpec(priv.getX(), dhParameters.getP(), dhParameters.getG());
        DHPrivateKey privKey = (DHPrivateKey) keyFac.generatePrivate(privKeySpecs);
        return new KeyPair(pubKey, privKey);
    } catch (Exception e) {
        throw new OtrCryptoException(e);
    }
}

Example 19 with DHPublicKey

use of javax.crypto.interfaces.DHPublicKey in project Gradle-demo by Arisono.

the class DHUtil method initKey.

/**
 * 甲方初始化并返回密钥对
 */
public static Map<String, Object> initKey() throws Exception {
    // 实例化密钥对生成器
    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DH");
    // 初始化密钥对生成器  默认是1024  512-1024 & 64的倍数
    keyPairGenerator.initialize(1024);
    // 生成密钥对
    KeyPair keyPair = keyPairGenerator.generateKeyPair();
    // 得到甲方公钥
    DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();
    // 得到甲方私钥
    DHPrivateKey peivateKey = (DHPrivateKey) keyPair.getPrivate();
    // 将公钥和私钥封装到Map中，方便之后使用
    Map<String, Object> keyMap = new HashMap<String, Object>();
    keyMap.put(PUBLIC_KEY, publicKey);
    keyMap.put(PRIVATE_KEY, peivateKey);
    return keyMap;
}

Example 20 with DHPublicKey

use of javax.crypto.interfaces.DHPublicKey in project jdk8u_jdk by JetBrains.

the class DHCrypt method checkConstraints.

// Check constraints of the specified DH public key.
void checkConstraints(AlgorithmConstraints constraints, BigInteger peerPublicValue) throws SSLHandshakeException {
    try {
        KeyFactory kf = JsseJce.getKeyFactory("DiffieHellman");
        DHPublicKeySpec spec = new DHPublicKeySpec(peerPublicValue, modulus, base);
        DHPublicKey publicKey = (DHPublicKey) kf.generatePublic(spec);
        // check constraints of DHPublicKey
        if (!constraints.permits(EnumSet.of(CryptoPrimitive.KEY_AGREEMENT), publicKey)) {
            throw new SSLHandshakeException("DHPublicKey does not comply to algorithm constraints");
        }
    } catch (GeneralSecurityException gse) {
        throw (SSLHandshakeException) new SSLHandshakeException("Could not generate DHPublicKey").initCause(gse);
    }
}