Example usage for org.bouncycastle.util.io.pem PemWriter writeObject

List of usage examples for org.bouncycastle.util.io.pem PemWriter writeObject

Introduction

In this page you can find the example usage for org.bouncycastle.util.io.pem PemWriter writeObject.

Prototype

public void writeObject(PemObjectGenerator objGen) throws IOException 

Source Link

Usage

From source file:ai.susi.server.api.aaa.PublicKeyRegistrationService.java

License:Open Source License

@Override
public JSONObject serviceImpl(Query post, HttpServletResponse response, Authorization authorization,
        final JsonObjectWithDefault permissions) throws APIException {

    if (post.get("register", null) == null && !post.get("create", false) && !post.get("getParameters", false)) {
        throw new APIException(400, "Accepted parameters: 'register', 'create' or 'getParameters'");
    }/* w  ww . ja v a2  s  . c o m*/

    JSONObject result = new JSONObject();

    // return algorithm parameters and users for whom we are allowed to register a key
    if (post.get("getParameters", false)) {
        result.put("self", permissions.getBoolean("self", false));
        result.put("users", permissions.getJSONObject("users"));
        result.put("userRoles", permissions.getJSONObject("userRoles"));

        JSONObject algorithms = new JSONObject();

        JSONObject rsa = new JSONObject();
        JSONArray keySizes = new JSONArray();
        for (int i : allowedKeySizesRSA) {
            keySizes.put(i);
        }
        rsa.put("sizes", keySizes);
        rsa.put("defaultSize", defaultKeySizeRSA);
        algorithms.put("RSA", rsa);
        result.put("algorithms", algorithms);

        JSONArray formats = new JSONArray();
        for (String format : allowedFormats) {
            formats.put(format);
        }
        result.put("formats", formats);

        return result;
    }

    // for which id?
    String id;
    if (post.get("id", null) != null)
        id = post.get("id", null);
    else
        id = authorization.getIdentity().getName();

    // check if we are allowed register a key
    if (!id.equals(authorization.getIdentity().getName())) { // if we don't want to register the key for the current user

        // create Authentication to check if the user id is a registered user
        ClientCredential credential = new ClientCredential(ClientCredential.Type.passwd_login, id);
        Authentication authentication = new Authentication(credential, DAO.authentication);

        if (authentication.getIdentity() == null) { // check if identity is valid
            authentication.delete();
            throw new APIException(400, "Bad request"); // do not leak if user exists or not
        }

        // check if the current user is allowed to create a key for the user in question
        boolean allowed = false;
        // check if the user in question is in 'users'
        if (permissions.getJSONObject("users", null).has(id)
                && permissions.getJSONObjectWithDefault("users", null).getBoolean(id, false)) {
            allowed = true;
        } else { // check if the user role of the user in question is in 'userRoles'
            Authorization auth = new Authorization(authentication.getIdentity(), DAO.authorization,
                    DAO.userRoles);
            for (String key : permissions.getJSONObject("userRoles").keySet()) {
                if (key.equals(auth.getUserRole().getName())
                        && permissions.getJSONObject("userRoles").getBoolean(key)) {
                    allowed = true;
                }
            }
        }
        if (!allowed)
            throw new APIException(400, "Bad request"); // do not leak if user exists or not
    } else { // if we want to register a key for this user, bad are not allowed to (for example anonymous users)
        if (!permissions.getBoolean("self", false))
            throw new APIException(403, "You are not allowed to register a public key");
    }

    // set algorithm. later, we maybe want to support other algorithms as well
    String algorithm = "RSA";
    if (post.get("algorithm", null) != null) {
        algorithm = post.get("algorithm", null);
    }

    if (post.get("create", false)) { // create a new key pair on the server

        if (algorithm.equals("RSA")) {
            int keySize = 2048;
            if (post.get("key-size", null) != null) {
                int finalKeyLength = post.get("key-size", 0);
                if (!IntStream.of(allowedKeySizesRSA).anyMatch(x -> x == finalKeyLength)) {
                    throw new APIException(400, "Invalid key size.");
                }
                keySize = finalKeyLength;
            }

            KeyPairGenerator keyGen;
            KeyPair keyPair;
            try {
                keyGen = KeyPairGenerator.getInstance(algorithm);
                keyGen.initialize(keySize);
                keyPair = keyGen.genKeyPair();
            } catch (NoSuchAlgorithmException e) {
                throw new APIException(500, "Server error");
            }

            registerKey(authorization.getIdentity(), keyPair.getPublic());

            String pubkey_pem = null, privkey_pem = null;
            try {
                StringWriter writer = new StringWriter();
                PemWriter pemWriter = new PemWriter(writer);
                pemWriter.writeObject(new PemObject("PUBLIC KEY", keyPair.getPublic().getEncoded()));
                pemWriter.flush();
                pemWriter.close();
                pubkey_pem = writer.toString();
            } catch (IOException e) {
            }
            try {
                StringWriter writer = new StringWriter();
                PemWriter pemWriter = new PemWriter(writer);
                pemWriter.writeObject(new PemObject("PRIVATE KEY", keyPair.getPrivate().getEncoded()));
                pemWriter.flush();
                pemWriter.close();
                privkey_pem = writer.toString();
            } catch (IOException e) {
            }

            result.put("publickey_DER_BASE64",
                    Base64.getEncoder().encodeToString(keyPair.getPublic().getEncoded()));
            result.put("privatekey_DER_BASE64",
                    Base64.getEncoder().encodeToString(keyPair.getPrivate().getEncoded()));
            result.put("publickey_PEM", pubkey_pem);
            result.put("privatekey_PEM", privkey_pem);
            result.put("keyhash", IO.getKeyHash(keyPair.getPublic()));
            try {
                result.put("keyhash_urlsave", URLEncoder.encode(IO.getKeyHash(keyPair.getPublic()), "UTF-8"));
            } catch (UnsupportedEncodingException e) {
            }
            result.put("key-size", keySize);
            result.put("message",
                    "Successfully created and registered key. Make sure to copy the private key, it won't be saved on the server");

            return result;
        }
        throw new APIException(400, "Unsupported algorithm");
    } else if (post.get("register", null) != null) {

        if (algorithm.equals("RSA")) {
            String type = post.get("type", null);
            if (type == null)
                type = "DER";

            RSAPublicKey pub;
            String encodedKey;
            try {
                encodedKey = URLDecoder.decode(post.get("register", null), "UTF-8");
            } catch (Throwable e) {
                throw new APIException(500, "Server error");
            }
            Log.getLog().info("Key (" + type + "): " + encodedKey);

            if (type.equals("DER")) {
                try {
                    X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(encodedKey));
                    pub = (RSAPublicKey) KeyFactory.getInstance(algorithm).generatePublic(keySpec);
                } catch (Throwable e) {
                    throw new APIException(400, "Public key not readable (DER)");
                }
            } else if (type.equals("PEM")) {
                try {
                    PemReader pemReader = new PemReader(new StringReader(encodedKey));
                    PemObject pem = pemReader.readPemObject();
                    X509EncodedKeySpec keySpec = new X509EncodedKeySpec(pem.getContent());
                    pub = (RSAPublicKey) KeyFactory.getInstance(algorithm).generatePublic(keySpec);
                } catch (Exception e) {
                    throw new APIException(400, "Public key not readable (PEM)");
                }
            } else {
                throw new APIException(400, "Invalid value for 'type'.");
            }

            // check key size (not really perfect yet)
            int keySize;
            int bitLength = pub.getModulus().bitLength();
            if (bitLength <= 512) {
                keySize = 512;
            } else if (bitLength <= 1024) {
                keySize = 1024;
            } else if (bitLength <= 2048) {
                keySize = 2048;
            } else if (bitLength <= 4096) {
                keySize = 4096;
            } else {
                keySize = 8192;
            }
            if (!IntStream.of(allowedKeySizesRSA).anyMatch(x -> x == keySize)) {
                throw new APIException(400, "Invalid key length.");
            }

            registerKey(authorization.getIdentity(), pub);

            String pubkey_pem = null;
            try {
                StringWriter writer = new StringWriter();
                PemWriter pemWriter = new PemWriter(writer);
                pemWriter.writeObject(new PemObject("PUBLIC KEY", pub.getEncoded()));
                pemWriter.flush();
                pemWriter.close();
                pubkey_pem = writer.toString();
            } catch (IOException e) {
            }

            result.put("publickey_DER_BASE64", Base64.getEncoder().encodeToString(pub.getEncoded()));
            result.put("publickey_PEM", pubkey_pem);
            result.put("keyhash", IO.getKeyHash(pub));
            try {
                result.put("keyhash_urlsave", URLEncoder.encode(IO.getKeyHash(pub), "UTF-8"));
            } catch (UnsupportedEncodingException e) {
            }
            result.put("message", "Successfully registered key.");

            return result;
        }
        throw new APIException(400, "Unsupported algorithm");
    }

    throw new APIException(400, "Invalid parameter");
}

From source file:bft.BFTNode.java

private byte[] getSerializedCertificate(X509CertificateHolder certificate) throws IOException {

    PemObject pemObj = (new PemObject("", certificate.getEncoded()));

    StringWriter strWriter = new StringWriter();
    PemWriter writer = new PemWriter(strWriter);
    writer.writeObject(pemObj);

    writer.close();/* w w  w  .j  a  v  a2  s .c  om*/
    strWriter.close();

    return strWriter.toString().getBytes();

}

From source file:bft.TestSignatures.java

private static void parseCertificate(String filename) throws IOException {

    BufferedReader br = new BufferedReader(new FileReader(filename));
    PEMParser pp = new PEMParser(br);
    X509CertificateHolder certificate = (X509CertificateHolder) pp.readObject();

    PemObject pemObj = (new PemObject("", certificate.getEncoded()));

    StringWriter strWriter = new StringWriter();
    PemWriter writer = new PemWriter(strWriter);
    writer.writeObject(pemObj);

    writer.close();//from ww  w  .  j a va  2s . c  o m
    strWriter.close();

    TestSignatures.serializedCert = strWriter.toString().getBytes();

}

From source file:bft.TestSignaturesZMQ.java

private static void parseCertificate(String filename) throws IOException {

    BufferedReader br = new BufferedReader(new FileReader(filename));
    PEMParser pp = new PEMParser(br);
    X509CertificateHolder certificate = (X509CertificateHolder) pp.readObject();

    PemObject pemObj = (new PemObject("", certificate.getEncoded()));

    StringWriter strWriter = new StringWriter();
    PemWriter writer = new PemWriter(strWriter);
    writer.writeObject(pemObj);

    writer.close();/* w w w. jav a  2s  . com*/
    strWriter.close();

    TestSignaturesZMQ.serializedCert = strWriter.toString().getBytes();

}

From source file:com.foilen.smalltools.crypt.bouncycastle.asymmetric.RSACrypt.java

License:Open Source License

@Override
public void saveKeysPem(AsymmetricKeys keyPair, String fileName) {
    AssertTools.assertNotNull(keyPair, "The keypair needs to be set to save it");
    AssertTools.assertNotNull(keyPair.getPrivateKey(), "The private key needs to be set to save it");
    AssertTools.assertNotNull(keyPair.getPublicKey(), "The public key needs to be set to save it");
    PemWriter pemWriter = null;
    try {/* ww w .  j  a  v  a2 s.  c o  m*/
        pemWriter = new PemWriter(new FileWriter(fileName));
        PemObjectGenerator pemObjectGenerator = new JcaMiscPEMGenerator(
                retrieveKeyDetails(keyPair).getJcaPrivateKey());
        pemWriter.writeObject(pemObjectGenerator);
        pemObjectGenerator = new JcaMiscPEMGenerator(retrieveKeyDetails(keyPair).getJcaPublicKey());
        pemWriter.writeObject(pemObjectGenerator);
    } catch (Exception e) {
        throw new SmallToolsException("Could not save keys", e);
    } finally {
        CloseableTools.close(pemWriter);
    }
}

From source file:com.foilen.smalltools.crypt.bouncycastle.asymmetric.RSACrypt.java

License:Open Source License

@Override
public void savePrivateKeyPem(AsymmetricKeys keyPair, Writer writer) {
    AssertTools.assertNotNull(keyPair, "The keypair needs to be set to save it");
    AssertTools.assertNotNull(keyPair.getPrivateKey(), "The private key needs to be set to save it");
    PemWriter pemWriter = null;
    try {/*from  w w  w.  j  a va2s.c  o  m*/
        pemWriter = new PemWriter(writer);
        PemObjectGenerator pemObjectGenerator = new JcaMiscPEMGenerator(
                retrieveKeyDetails(keyPair).getJcaPrivateKey());
        pemWriter.writeObject(pemObjectGenerator);
    } catch (Exception e) {
        throw new SmallToolsException("Could not save key", e);
    } finally {
        CloseableTools.close(pemWriter);
    }
}

From source file:com.foilen.smalltools.crypt.bouncycastle.asymmetric.RSACrypt.java

License:Open Source License

@Override
public void savePublicKeyPem(AsymmetricKeys keyPair, Writer writer) {
    AssertTools.assertNotNull(keyPair, "The public keys need to be set to save it");
    AssertTools.assertNotNull(keyPair.getPublicKey(), "The public key needs to be set to save it");
    PemWriter pemWriter = null;
    try {/*from   w  ww  .  j ava2 s  .  c  o m*/
        pemWriter = new PemWriter(writer);
        PemObjectGenerator pemObjectGenerator = new JcaMiscPEMGenerator(
                retrieveKeyDetails(keyPair).getJcaPublicKey());
        pemWriter.writeObject(pemObjectGenerator);
    } catch (Exception e) {
        throw new SmallToolsException("Could not save key", e);
    } finally {
        CloseableTools.close(pemWriter);
    }
}

From source file:com.foilen.smalltools.crypt.bouncycastle.cert.RSACertificate.java

License:Open Source License

/**
 * Save the certificate in a PEM writer.
 *
 * @param writer//from w ww. j av a2  s.  co m
 *            the writer. Will be closed at the end
 */
public void saveCertificatePem(Writer writer) {
    AssertTools.assertNotNull(certificateHolder, "The certificate is not set");
    PemWriter pemWriter = null;
    try {
        pemWriter = new PemWriter(writer);
        PemObjectGenerator pemObjectGenerator = new MiscPEMGenerator(certificateHolder);
        pemWriter.writeObject(pemObjectGenerator);
    } catch (Exception e) {
        throw new SmallToolsException("Could not save cert", e);
    } finally {
        CloseableTools.close(pemWriter);
    }
}

From source file:com.thoughtworks.go.security.Registration.java

License:Apache License

private String serialize(String type, byte[] data) {
    PemObject obj = new PemObject(type, data);
    StringWriter out = new StringWriter();
    PemWriter writer = new PemWriter(out);
    try {//from  w w  w  .java2  s  . co m
        writer.writeObject(obj);
    } catch (IOException e) {
        throw bomb(e);
    } finally {
        IOUtils.closeQuietly(writer);
    }
    return out.toString();
}

From source file:com.thoughtworks.go.security.RegistrationJSONizer.java

License:Apache License

private static String serialize(String type, byte[] data) {
    PemObject obj = new PemObject(type, data);
    StringWriter out = new StringWriter();
    PemWriter writer = new PemWriter(out);
    try {//w  w w  .j  av  a2  s .  c  o m
        writer.writeObject(obj);
    } catch (IOException e) {
        throw bomb(e);
    } finally {
        IOUtils.closeQuietly(writer);
    }
    return out.toString();
}