Example usage for org.bouncycastle.asn1.x509 TBSCertificate getSubject

List of usage examples for org.bouncycastle.asn1.x509 TBSCertificate getSubject

Introduction

In this page you can find the example usage for org.bouncycastle.asn1.x509 TBSCertificate getSubject.

Prototype

public X500Name getSubject() 

Source Link

Usage

From source file:org.xipki.pki.ca.dbtool.port.CaCertStoreDbImporter.java

License:Open Source License

private long doImportEntries(final CaDbEntryType type, final String entriesZipFile, final long minId,
        final File processLogFile, final ProcessLog processLog, final int numProcessedInLastProcess,
        final PreparedStatement[] statements, final String[] sqls) throws Exception {
    final int numEntriesPerCommit = Math.max(1, Math.round(type.getSqlBatchFactor() * numCertsPerCommit));

    ZipFile zipFile = new ZipFile(new File(entriesZipFile));
    ZipEntry entriesXmlEntry = zipFile.getEntry("overview.xml");

    DbiXmlReader entries;//from  w w  w . j av a 2  s  . c o m
    try {
        entries = createReader(type, zipFile.getInputStream(entriesXmlEntry));
    } catch (Exception ex) {
        try {
            zipFile.close();
        } catch (Exception e2) {
            LOG.error("could not close ZIP file {}: {}", entriesZipFile, e2.getMessage());
            LOG.debug("could not close ZIP file " + entriesZipFile, e2);
        }
        throw ex;
    }

    disableAutoCommit();

    try {
        int numEntriesInBatch = 0;
        long lastSuccessfulEntryId = 0;

        while (entries.hasNext()) {
            if (stopMe.get()) {
                throw new InterruptedException("interrupted by the user");
            }

            IdentifidDbObjectType entry = (IdentifidDbObjectType) entries.next();
            long id = entry.getId();
            if (id < minId) {
                continue;
            }

            numEntriesInBatch++;

            if (CaDbEntryType.CERT == type) {
                CaCertType cert = (CaCertType) entry;
                int certArt = (cert.getArt() == null) ? 1 : cert.getArt();

                String filename = cert.getFile();
                // rawcert
                ZipEntry certZipEnty = zipFile.getEntry(filename);
                // rawcert
                byte[] encodedCert = IoUtil.read(zipFile.getInputStream(certZipEnty));

                TBSCertificate tbsCert;
                try {
                    Certificate cc = Certificate.getInstance(encodedCert);
                    tbsCert = cc.getTBSCertificate();
                } catch (RuntimeException ex) {
                    LOG.error("could not parse certificate in file {}", filename);
                    LOG.debug("could not parse certificate in file " + filename, ex);
                    throw new CertificateException(ex.getMessage(), ex);
                }

                byte[] encodedKey = tbsCert.getSubjectPublicKeyInfo().getPublicKeyData().getBytes();

                String b64Sha1FpCert = HashAlgoType.SHA1.base64Hash(encodedCert);

                // cert
                String subjectText = X509Util.cutX500Name(tbsCert.getSubject(), maxX500nameLen);

                PreparedStatement psCert = statements[0];
                PreparedStatement psRawcert = statements[1];

                try {
                    int idx = 1;

                    psCert.setLong(idx++, id);
                    psCert.setInt(idx++, certArt);
                    psCert.setLong(idx++, cert.getUpdate());
                    psCert.setString(idx++, tbsCert.getSerialNumber().getPositiveValue().toString(16));

                    psCert.setString(idx++, subjectText);
                    long fpSubject = X509Util.fpCanonicalizedName(tbsCert.getSubject());
                    psCert.setLong(idx++, fpSubject);

                    if (cert.getFpRs() != null) {
                        psCert.setLong(idx++, cert.getFpRs());
                    } else {
                        psCert.setNull(idx++, Types.BIGINT);
                    }

                    psCert.setLong(idx++, tbsCert.getStartDate().getDate().getTime() / 1000);
                    psCert.setLong(idx++, tbsCert.getEndDate().getDate().getTime() / 1000);
                    setBoolean(psCert, idx++, cert.getRev());
                    setInt(psCert, idx++, cert.getRr());
                    setLong(psCert, idx++, cert.getRt());
                    setLong(psCert, idx++, cert.getRit());
                    setInt(psCert, idx++, cert.getPid());
                    setInt(psCert, idx++, cert.getCaId());

                    setInt(psCert, idx++, cert.getRid());
                    psCert.setString(idx++, cert.getUser());
                    psCert.setLong(idx++, FpIdCalculator.hash(encodedKey));
                    Extension extension = tbsCert.getExtensions().getExtension(Extension.basicConstraints);
                    boolean ee = true;
                    if (extension != null) {
                        ASN1Encodable asn1 = extension.getParsedValue();
                        ee = !BasicConstraints.getInstance(asn1).isCA();
                    }

                    psCert.setInt(idx++, ee ? 1 : 0);
                    psCert.setInt(idx++, cert.getReqType());
                    String tidS = null;
                    if (cert.getTid() != null) {
                        tidS = cert.getTid();
                    }
                    psCert.setString(idx++, tidS);
                    psCert.addBatch();
                } catch (SQLException ex) {
                    throw translate(SQL_ADD_CERT, ex);
                }

                try {
                    int idx = 1;
                    psRawcert.setLong(idx++, cert.getId());
                    psRawcert.setString(idx++, b64Sha1FpCert);
                    psRawcert.setString(idx++, cert.getRs());
                    psRawcert.setString(idx++, Base64.toBase64String(encodedCert));
                    psRawcert.addBatch();
                } catch (SQLException ex) {
                    throw translate(SQL_ADD_CRAW, ex);
                }
            } else if (CaDbEntryType.CRL == type) {
                PreparedStatement psAddCrl = statements[0];

                CaCrlType crl = (CaCrlType) entry;

                String filename = crl.getFile();

                // CRL
                ZipEntry zipEnty = zipFile.getEntry(filename);

                // rawcert
                byte[] encodedCrl = IoUtil.read(zipFile.getInputStream(zipEnty));

                X509CRL x509crl = null;
                try {
                    x509crl = X509Util.parseCrl(encodedCrl);
                } catch (Exception ex) {
                    LOG.error("could not parse CRL in file {}", filename);
                    LOG.debug("could not parse CRL in file " + filename, ex);
                    if (ex instanceof CRLException) {
                        throw (CRLException) ex;
                    } else {
                        throw new CRLException(ex.getMessage(), ex);
                    }
                }

                try {
                    byte[] octetString = x509crl.getExtensionValue(Extension.cRLNumber.getId());
                    if (octetString == null) {
                        LOG.warn("CRL without CRL number, ignore it");
                        continue;
                    }
                    byte[] extnValue = DEROctetString.getInstance(octetString).getOctets();
                    // CHECKSTYLE:SKIP
                    BigInteger crlNumber = ASN1Integer.getInstance(extnValue).getPositiveValue();

                    BigInteger baseCrlNumber = null;
                    octetString = x509crl.getExtensionValue(Extension.deltaCRLIndicator.getId());
                    if (octetString != null) {
                        extnValue = DEROctetString.getInstance(octetString).getOctets();
                        baseCrlNumber = ASN1Integer.getInstance(extnValue).getPositiveValue();
                    }

                    int idx = 1;
                    psAddCrl.setLong(idx++, crl.getId());
                    psAddCrl.setInt(idx++, crl.getCaId());
                    psAddCrl.setLong(idx++, crlNumber.longValue());
                    psAddCrl.setLong(idx++, x509crl.getThisUpdate().getTime() / 1000);
                    if (x509crl.getNextUpdate() != null) {
                        psAddCrl.setLong(idx++, x509crl.getNextUpdate().getTime() / 1000);
                    } else {
                        psAddCrl.setNull(idx++, Types.INTEGER);
                    }

                    if (baseCrlNumber == null) {
                        setBoolean(psAddCrl, idx++, false);
                        psAddCrl.setNull(idx++, Types.BIGINT);
                    } else {
                        setBoolean(psAddCrl, idx++, true);
                        psAddCrl.setLong(idx++, baseCrlNumber.longValue());
                    }

                    String str = Base64.toBase64String(encodedCrl);
                    psAddCrl.setString(idx++, str);

                    psAddCrl.addBatch();
                } catch (SQLException ex) {
                    System.err.println(
                            "could not import CRL with ID=" + crl.getId() + ", message: " + ex.getMessage());
                    throw ex;
                }
            } else if (CaDbEntryType.USER == type) {
                PreparedStatement psAddUser = statements[0];
                CaUserType user = (CaUserType) entry;

                try {
                    int idx = 1;
                    psAddUser.setLong(idx++, user.getId());
                    psAddUser.setString(idx++, user.getName());
                    psAddUser.setString(idx++, user.getPassword());
                    psAddUser.setString(idx++, user.getCnRegex());
                    psAddUser.addBatch();
                } catch (SQLException ex) {
                    System.err.println("could not import USERNAME with ID=" + user.getId() + ", message: "
                            + ex.getMessage());
                    throw ex;
                }
            } else if (CaDbEntryType.REQUEST == type) {
                PreparedStatement psAddRequest = statements[0];

                CaRequestType request = (CaRequestType) entry;

                String filename = request.getFile();

                ZipEntry zipEnty = zipFile.getEntry(filename);
                byte[] encodedRequest = IoUtil.read(zipFile.getInputStream(zipEnty));

                try {
                    int idx = 1;
                    psAddRequest.setLong(idx++, request.getId());
                    psAddRequest.setLong(idx++, request.getUpdate());
                    psAddRequest.setString(idx++, Base64.toBase64String(encodedRequest));
                    psAddRequest.addBatch();
                } catch (SQLException ex) {
                    System.err.println("could not import REQUEST with ID=" + request.getId() + ", message: "
                            + ex.getMessage());
                    throw ex;
                }
            } else if (CaDbEntryType.REQCERT == type) {
                PreparedStatement psAddReqCert = statements[0];

                CaRequestCertType reqCert = (CaRequestCertType) entry;

                try {
                    int idx = 1;
                    psAddReqCert.setLong(idx++, reqCert.getId());
                    psAddReqCert.setLong(idx++, reqCert.getRid());
                    psAddReqCert.setLong(idx++, reqCert.getCid());
                    psAddReqCert.addBatch();
                } catch (SQLException ex) {
                    System.err.println("could not import REQUEST with ID=" + reqCert.getId() + ", message: "
                            + ex.getMessage());
                    throw ex;
                }
            } else {
                throw new RuntimeException("Unknown CaDbEntryType " + type);
            }

            boolean isLastBlock = !entries.hasNext();
            if (numEntriesInBatch > 0 && (numEntriesInBatch % numEntriesPerCommit == 0 || isLastBlock)) {
                if (evaulateOnly) {
                    for (PreparedStatement m : statements) {
                        m.clearBatch();
                    }
                } else {
                    String sql = null;

                    try {
                        for (int i = 0; i < sqls.length; i++) {
                            sql = sqls[i];
                            statements[i].executeBatch();
                        }

                        sql = null;
                        commit("(commit import to CA)");
                    } catch (Throwable th) {
                        rollback();
                        deleteFromTableWithLargerId(type.getTableName(), "ID", id, LOG);
                        if (CaDbEntryType.CERT == type) {
                            deleteFromTableWithLargerId("CRAW", "CID", id, LOG);
                        }
                        if (th instanceof SQLException) {
                            throw translate(sql, (SQLException) th);
                        } else if (th instanceof Exception) {
                            throw (Exception) th;
                        } else {
                            throw new Exception(th);
                        }
                    }
                }

                lastSuccessfulEntryId = id;
                processLog.addNumProcessed(numEntriesInBatch);
                numEntriesInBatch = 0;
                echoToFile(type + ":" + (numProcessedInLastProcess + processLog.getNumProcessed()) + ":"
                        + lastSuccessfulEntryId, processLogFile);
                processLog.printStatus();
            }

        } // end while

        return lastSuccessfulEntryId;
    } finally {
        recoverAutoCommit();
        zipFile.close();
    }
}

From source file:org.xipki.pki.ca.dbtool.port.OcspCertStoreDbImporter.java

License:Open Source License

private long doImportCert(final PreparedStatement psCert, final PreparedStatement psCerthash,
        final PreparedStatement psRawcert, final String certsZipFile, final long minId,
        final File processLogFile, final ProcessLog processLog, final int numProcessedInLastProcess)
        throws Exception {
    ZipFile zipFile = new ZipFile(new File(certsZipFile));
    ZipEntry certsXmlEntry = zipFile.getEntry("certs.xml");

    OcspCertsReader certs;/*from   ww  w .  j  a v a  2  s  . c o  m*/
    try {
        certs = new OcspCertsReader(zipFile.getInputStream(certsXmlEntry));
    } catch (Exception ex) {
        try {
            zipFile.close();
        } catch (Exception e2) {
            LOG.error("could not close ZIP file {}: {}", certsZipFile, e2.getMessage());
            LOG.debug("could not close ZIP file " + certsZipFile, e2);
        }
        throw ex;
    }

    disableAutoCommit();

    try {
        int numEntriesInBatch = 0;
        long lastSuccessfulCertId = 0;

        while (certs.hasNext()) {
            if (stopMe.get()) {
                throw new InterruptedException("interrupted by the user");
            }

            OcspCertType cert = (OcspCertType) certs.next();

            long id = cert.getId();
            if (id < minId) {
                continue;
            }

            numEntriesInBatch++;
            String filename = cert.getFile();

            // rawcert
            ZipEntry certZipEnty = zipFile.getEntry(filename);
            // rawcert
            byte[] encodedCert = IoUtil.read(zipFile.getInputStream(certZipEnty));

            TBSCertificate tbsCert;
            try {
                Certificate cc = Certificate.getInstance(encodedCert);
                tbsCert = cc.getTBSCertificate();
            } catch (RuntimeException ex) {
                LOG.error("could not parse certificate in file {}", filename);
                LOG.debug("could not parse certificate in file " + filename, ex);
                throw new CertificateException(ex.getMessage(), ex);
            }

            // cert
            try {
                int idx = 1;
                psCert.setLong(idx++, id);
                psCert.setInt(idx++, cert.getIid());
                psCert.setString(idx++, tbsCert.getSerialNumber().getPositiveValue().toString(16));
                psCert.setLong(idx++, cert.getUpdate());
                psCert.setLong(idx++, tbsCert.getStartDate().getDate().getTime() / 1000);
                psCert.setLong(idx++, tbsCert.getEndDate().getDate().getTime() / 1000);
                setBoolean(psCert, idx++, cert.getRev().booleanValue());
                setInt(psCert, idx++, cert.getRr());
                setLong(psCert, idx++, cert.getRt());
                setLong(psCert, idx++, cert.getRit());
                psCert.setString(idx++, cert.getProfile());
                psCert.addBatch();
            } catch (SQLException ex) {
                throw translate(SQL_ADD_CERT, ex);
            }

            // certhash
            try {
                int idx = 1;
                psCerthash.setLong(idx++, cert.getId());
                psCerthash.setString(idx++, sha1(encodedCert));
                psCerthash.setString(idx++, sha224(encodedCert));
                psCerthash.setString(idx++, sha256(encodedCert));
                psCerthash.setString(idx++, sha384(encodedCert));
                psCerthash.setString(idx++, sha512(encodedCert));
                psCerthash.addBatch();
            } catch (SQLException ex) {
                throw translate(SQL_ADD_CHASH, ex);
            }

            // rawcert
            try {
                int idx = 1;
                psRawcert.setLong(idx++, cert.getId());
                psRawcert.setString(idx++, X509Util.cutX500Name(tbsCert.getSubject(), maxX500nameLen));
                psRawcert.setString(idx++, Base64.toBase64String(encodedCert));
                psRawcert.addBatch();
            } catch (SQLException ex) {
                throw translate(SQL_ADD_CRAW, ex);
            }

            boolean isLastBlock = !certs.hasNext();

            if (numEntriesInBatch > 0 && (numEntriesInBatch % this.numCertsPerCommit == 0 || isLastBlock)) {
                if (evaulateOnly) {
                    psCert.clearBatch();
                    psCerthash.clearBatch();
                    psRawcert.clearBatch();
                } else {
                    String sql = null;
                    try {
                        sql = SQL_ADD_CERT;
                        psCert.executeBatch();

                        sql = SQL_ADD_CHASH;
                        psCerthash.executeBatch();

                        sql = SQL_ADD_CRAW;
                        psRawcert.executeBatch();

                        sql = null;
                        commit("(commit import cert to OCSP)");
                    } catch (Throwable th) {
                        rollback();
                        deleteCertGreatherThan(lastSuccessfulCertId, LOG);
                        if (th instanceof SQLException) {
                            throw translate(sql, (SQLException) th);
                        } else if (th instanceof Exception) {
                            throw (Exception) th;
                        } else {
                            throw new Exception(th);
                        }
                    }
                }

                lastSuccessfulCertId = id;
                processLog.addNumProcessed(numEntriesInBatch);
                numEntriesInBatch = 0;
                echoToFile(
                        (numProcessedInLastProcess + processLog.getNumProcessed()) + ":" + lastSuccessfulCertId,
                        processLogFile);
                processLog.printStatus();
            }
        } // end for

        return lastSuccessfulCertId;
    } finally {
        recoverAutoCommit();
        zipFile.close();
    }
}

From source file:org.xipki.pki.ca.dbtool.port.OcspCertStoreFromCaDbImporter.java

License:Open Source License

private long doImportCert(final ImportStatements statments, final String certsZipFile,
        final Map<Integer, String> profileMap, final boolean revokedOnly, final List<Integer> caIds,
        final long minId, final File processLogFile, final ProcessLog processLog,
        final int numProcessedInLastProcess, final ProcessLog importLog) throws Exception {
    ZipFile zipFile = new ZipFile(new File(certsZipFile));
    ZipEntry certsXmlEntry = zipFile.getEntry("overview.xml");

    CaCertsReader certs;/*from   w  ww.  ja va  2  s.c o m*/
    try {
        certs = new CaCertsReader(zipFile.getInputStream(certsXmlEntry));
    } catch (Exception ex) {
        try {
            zipFile.close();
        } catch (Exception ex2) {
            LOG.error("could not close ZIP file {}: {}", certsZipFile, ex2.getMessage());
            LOG.debug("could not close ZIP file " + certsZipFile, ex2);
        }
        throw ex;
    }

    disableAutoCommit();

    PreparedStatement psCert = statments.psCert;
    PreparedStatement psCerthash = statments.psCerthash;
    PreparedStatement psRawCert = statments.psRawCert;

    try {
        int numProcessedEntriesInBatch = 0;
        int numImportedEntriesInBatch = 0;
        long lastSuccessfulCertId = 0;

        while (certs.hasNext()) {
            if (stopMe.get()) {
                throw new InterruptedException("interrupted by the user");
            }

            CaCertType cert = (CaCertType) certs.next();

            long id = cert.getId();
            lastSuccessfulCertId = id;
            if (id < minId) {
                continue;
            }

            numProcessedEntriesInBatch++;

            if (!revokedOnly || cert.getRev().booleanValue()) {
                int caId = cert.getCaId();
                if (caIds.contains(caId)) {
                    numImportedEntriesInBatch++;

                    String filename = cert.getFile();

                    // rawcert
                    ZipEntry certZipEnty = zipFile.getEntry(filename);
                    // rawcert
                    byte[] encodedCert = IoUtil.read(zipFile.getInputStream(certZipEnty));

                    TBSCertificate tbsCert;
                    try {
                        Certificate cc = Certificate.getInstance(encodedCert);
                        tbsCert = cc.getTBSCertificate();
                    } catch (RuntimeException ex) {
                        LOG.error("could not parse certificate in file {}", filename);
                        LOG.debug("could not parse certificate in file " + filename, ex);
                        throw new CertificateException(ex.getMessage(), ex);
                    }

                    // cert
                    try {
                        int idx = 1;
                        psCert.setLong(idx++, id);
                        psCert.setInt(idx++, caId);
                        psCert.setString(idx++, tbsCert.getSerialNumber().getPositiveValue().toString(16));
                        psCert.setLong(idx++, cert.getUpdate());
                        psCert.setLong(idx++, tbsCert.getStartDate().getDate().getTime() / 1000);
                        psCert.setLong(idx++, tbsCert.getEndDate().getDate().getTime() / 1000);
                        setBoolean(psCert, idx++, cert.getRev());
                        setInt(psCert, idx++, cert.getRr());
                        setLong(psCert, idx++, cert.getRt());
                        setLong(psCert, idx++, cert.getRit());

                        int certprofileId = cert.getPid();
                        String certprofileName = profileMap.get(certprofileId);
                        psCert.setString(idx++, certprofileName);
                        psCert.addBatch();
                    } catch (SQLException ex) {
                        throw translate(SQL_ADD_CERT, ex);
                    }

                    // certhash
                    try {
                        int idx = 1;
                        psCerthash.setLong(idx++, id);
                        psCerthash.setString(idx++, HashAlgoType.SHA1.base64Hash(encodedCert));
                        psCerthash.setString(idx++, HashAlgoType.SHA224.base64Hash(encodedCert));
                        psCerthash.setString(idx++, HashAlgoType.SHA256.base64Hash(encodedCert));
                        psCerthash.setString(idx++, HashAlgoType.SHA384.base64Hash(encodedCert));
                        psCerthash.setString(idx++, HashAlgoType.SHA512.base64Hash(encodedCert));
                        psCerthash.addBatch();
                    } catch (SQLException ex) {
                        throw translate(SQL_ADD_CHASH, ex);
                    }

                    // rawcert
                    try {
                        int idx = 1;
                        psRawCert.setLong(idx++, id);
                        psRawCert.setString(idx++, X509Util.cutX500Name(tbsCert.getSubject(), maxX500nameLen));
                        psRawCert.setString(idx++, Base64.toBase64String(encodedCert));
                        psRawCert.addBatch();
                    } catch (SQLException ex) {
                        throw translate(SQL_ADD_CRAW, ex);
                    }
                } // end if (caIds.contains(caId))
            } // end if (revokedOnly

            boolean isLastBlock = !certs.hasNext();

            if (numImportedEntriesInBatch > 0
                    && (numImportedEntriesInBatch % this.numCertsPerCommit == 0 || isLastBlock)) {
                if (evaulateOnly) {
                    psCert.clearBatch();
                    psCerthash.clearBatch();
                    psRawCert.clearBatch();
                } else {
                    String sql = null;
                    try {
                        sql = SQL_ADD_CERT;
                        psCert.executeBatch();

                        sql = SQL_ADD_CHASH;
                        psCerthash.executeBatch();

                        sql = SQL_ADD_CRAW;
                        psRawCert.executeBatch();

                        sql = null;
                        commit("(commit import cert to OCSP)");
                    } catch (Throwable th) {
                        rollback();
                        deleteCertGreatherThan(lastSuccessfulCertId, LOG);
                        if (th instanceof SQLException) {
                            throw translate(sql, (SQLException) th);
                        } else if (th instanceof Exception) {
                            throw (Exception) th;
                        } else {
                            throw new Exception(th);
                        }
                    }
                }

                lastSuccessfulCertId = id;
                processLog.addNumProcessed(numProcessedEntriesInBatch);
                importLog.addNumProcessed(numImportedEntriesInBatch);
                numProcessedEntriesInBatch = 0;
                numImportedEntriesInBatch = 0;
                String filename = (numProcessedInLastProcess + processLog.getNumProcessed()) + ":"
                        + lastSuccessfulCertId;
                echoToFile(filename, processLogFile);
                processLog.printStatus();
            } else if (isLastBlock) {
                lastSuccessfulCertId = id;
                processLog.addNumProcessed(numProcessedEntriesInBatch);
                importLog.addNumProcessed(numImportedEntriesInBatch);
                numProcessedEntriesInBatch = 0;
                numImportedEntriesInBatch = 0;
                String filename = (numProcessedInLastProcess + processLog.getNumProcessed()) + ":"
                        + lastSuccessfulCertId;
                echoToFile(filename, processLogFile);
                processLog.printStatus();
            }
            // if (numImportedEntriesInBatch)
        } // end for

        return lastSuccessfulCertId;
    } finally {
        recoverAutoCommit();
        zipFile.close();
    }
}