src/org/cacert/gigi/Certificate.java

   1 package org.cacert.gigi;
   2
   3 import java.io.File;
   4 import java.io.FileInputStream;
   5 import java.io.FileOutputStream;
   6 import java.io.IOException;
   7 import java.io.InputStream;
   8 import java.security.GeneralSecurityException;
   9 import java.security.cert.CertificateFactory;
  10 import java.security.cert.X509Certificate;
  11 import java.sql.Date;
  12 import java.sql.PreparedStatement;
  13 import java.sql.ResultSet;
  14 import java.sql.SQLException;
  15 import java.util.Arrays;
  16 import java.util.Collections;
  17 import java.util.LinkedList;
  18 import java.util.List;
  19
  20 import org.cacert.gigi.database.DatabaseConnection;
  21 import org.cacert.gigi.util.Job;
  22 import org.cacert.gigi.util.KeyStorage;
  23 import org.cacert.gigi.util.Notary;
  24
  25 public class Certificate {
  26
  27     public enum SANType {
  28         EMAIL("email"), DNS("DNS");
  29
  30         private final String opensslName;
  31
  32         private SANType(String opensslName) {
  33             this.opensslName = opensslName;
  34         }
  35
  36         public String getOpensslName() {
  37             return opensslName;
  38         }
  39     }
  40
  41     public static class SubjectAlternateName implements Comparable<SubjectAlternateName> {
  42
  43         private SANType type;
  44
  45         private String name;
  46
  47         public SubjectAlternateName(SANType type, String name) {
  48             this.type = type;
  49             this.name = name;
  50         }
  51
  52         public String getName() {
  53             return name;
  54         }
  55
  56         public SANType getType() {
  57             return type;
  58         }
  59
  60         @Override
  61         public int compareTo(SubjectAlternateName o) {
  62             int i = type.compareTo(o.type);
  63             if (i != 0) {
  64                 return i;
  65             }
  66             return name.compareTo(o.name);
  67         }
  68
  69         @Override
  70         public int hashCode() {
  71             final int prime = 31;
  72             int result = 1;
  73             result = prime * result + ((name == null) ? 0 : name.hashCode());
  74             result = prime * result + ((type == null) ? 0 : type.hashCode());
  75             return result;
  76         }
  77
  78         @Override
  79         public boolean equals(Object obj) {
  80             if (this == obj) {
  81                 return true;
  82             }
  83             if (obj == null) {
  84                 return false;
  85             }
  86             if (getClass() != obj.getClass()) {
  87                 return false;
  88             }
  89             SubjectAlternateName other = (SubjectAlternateName) obj;
  90             if (name == null) {
  91                 if (other.name != null) {
  92                     return false;
  93                 }
  94             } else if ( !name.equals(other.name)) {
  95                 return false;
  96             }
  97             if (type != other.type) {
  98                 return false;
  99             }
 100             return true;
 101         }
 102
 103     }
 104
 105     public enum CSRType {
 106         CSR, SPKAC;
 107     }
 108
 109     private int id;
 110
 111     private int ownerId;
 112
 113     private String serial;
 114
 115     private String dn;
 116
 117     private String md;
 118
 119     private String csrName;
 120
 121     private String crtName;
 122
 123     private String csr = null;
 124
 125     private CSRType csrType;
 126
 127     private List<SubjectAlternateName> sans;
 128
 129     private CertificateProfile profile;
 130
 131     public Certificate(int ownerId, String dn, String md, String csr, CSRType csrType, CertificateProfile profile, SubjectAlternateName... sans) {
 132         this.ownerId = ownerId;
 133         this.dn = dn;
 134         this.md = md;
 135         this.csr = csr;
 136         this.csrType = csrType;
 137         this.profile = profile;
 138         this.sans = Arrays.asList(sans);
 139     }
 140
 141     private Certificate(String serial) {
 142         try {
 143             PreparedStatement ps = DatabaseConnection.getInstance().prepare("SELECT id,subject, md, csr_name, crt_name,memid, profile FROM `certs` WHERE serial=?");
 144             ps.setString(1, serial);
 145             ResultSet rs = ps.executeQuery();
 146             if ( !rs.next()) {
 147                 throw new IllegalArgumentException("Invalid mid " + serial);
 148             }
 149             this.id = rs.getInt(1);
 150             dn = rs.getString(2);
 151             md = rs.getString(3);
 152             csrName = rs.getString(4);
 153             crtName = rs.getString(5);
 154             ownerId = rs.getInt(6);
 155             profile = CertificateProfile.getById(rs.getInt(7));
 156             this.serial = serial;
 157
 158             PreparedStatement ps2 = DatabaseConnection.getInstance().prepare("SELECT contents, type FROM `subjectAlternativeNames` WHERE certId=?");
 159             ps2.setInt(1, id);
 160             ResultSet rs2 = ps2.executeQuery();
 161             sans = new LinkedList<>();
 162             while (rs2.next()) {
 163                 sans.add(new SubjectAlternateName(SANType.valueOf(rs2.getString("type").toUpperCase()), rs2.getString("contents")));
 164             }
 165             rs2.close();
 166
 167             rs.close();
 168         } catch (SQLException e) {
 169             e.printStackTrace();
 170         }
 171     }
 172
 173     public enum CertificateStatus {
 174         /**
 175          * This certificate is not in the database, has no id and only exists as
 176          * this java object.
 177          */
 178         DRAFT(),
 179         /**
 180          * The certificate has been signed. It is stored in the database.
 181          * {@link Certificate#cert()} is valid.
 182          */
 183         ISSUED(),
 184
 185         /**
 186          * The certificate has been revoked.
 187          */
 188         REVOKED(),
 189
 190         /**
 191          * If this certificate cannot be updated because an error happened in
 192          * the signer.
 193          */
 194         ERROR();
 195
 196         private CertificateStatus() {}
 197
 198     }
 199
 200     public CertificateStatus getStatus() throws SQLException {
 201         if (id == 0) {
 202             return CertificateStatus.DRAFT;
 203         }
 204         PreparedStatement searcher = DatabaseConnection.getInstance().prepare("SELECT crt_name, created, revoked, serial FROM certs WHERE id=?");
 205         searcher.setInt(1, id);
 206         ResultSet rs = searcher.executeQuery();
 207         if ( !rs.next()) {
 208             throw new IllegalStateException("Certificate not in Database");
 209         }
 210
 211         crtName = rs.getString(1);
 212         serial = rs.getString(4);
 213         if (rs.getTime(2) == null) {
 214             return CertificateStatus.DRAFT;
 215         }
 216         if (rs.getTime(2) != null && rs.getTime(3) == null) {
 217             return CertificateStatus.ISSUED;
 218         }
 219         return CertificateStatus.REVOKED;
 220     }
 221
 222     /**
 223      * @param start
 224      *            the date from which on the certificate should be valid. (or
 225      *            null if it should be valid instantly)
 226      * @param period
 227      *            the period for which the date should be valid. (a
 228      *            <code>yyyy-mm-dd</code> or a "2y" (2 calendar years), "6m" (6
 229      *            months)
 230      * @return A job which can be used to monitor the progress of this task.
 231      * @throws IOException
 232      *             for problems with writing the CSR/SPKAC
 233      * @throws SQLException
 234      *             for problems with writing to the DB
 235      * @throws GigiApiException
 236      *             if the period is bogus
 237      */
 238     public Job issue(Date start, String period) throws IOException, SQLException, GigiApiException {
 239         if (getStatus() != CertificateStatus.DRAFT) {
 240             throw new IllegalStateException();
 241         }
 242         Notary.writeUserAgreement(ownerId, "CCA", "issue certificate", "", true, 0);
 243
 244         PreparedStatement inserter = DatabaseConnection.getInstance().prepare("INSERT INTO certs SET md=?, subject=?, csr_type=?, crt_name='', memid=?, profile=?");
 245         inserter.setString(1, md);
 246         inserter.setString(2, dn);
 247         inserter.setString(3, csrType.toString());
 248         inserter.setInt(4, ownerId);
 249         inserter.setInt(5, profile.getId());
 250         inserter.execute();
 251         id = DatabaseConnection.lastInsertId(inserter);
 252         File csrFile = KeyStorage.locateCsr(id);
 253         csrName = csrFile.getPath();
 254         FileOutputStream fos = new FileOutputStream(csrFile);
 255         fos.write(csr.getBytes());
 256         fos.close();
 257
 258         // TODO draft to insert SANs
 259         PreparedStatement san = DatabaseConnection.getInstance().prepare("INSERT INTO subjectAlternativeNames SET certId=?, contents=?, type=?");
 260         for (SubjectAlternateName subjectAlternateName : sans) {
 261             san.setInt(1, id);
 262             san.setString(2, subjectAlternateName.getName());
 263             san.setString(3, subjectAlternateName.getType().getOpensslName());
 264             san.execute();
 265         }
 266
 267         PreparedStatement updater = DatabaseConnection.getInstance().prepare("UPDATE certs SET csr_name=? WHERE id=?");
 268         updater.setString(1, csrName);
 269         updater.setInt(2, id);
 270         updater.execute();
 271         return Job.sign(this, start, period);
 272
 273     }
 274
 275     public Job revoke() throws SQLException {
 276         if (getStatus() != CertificateStatus.ISSUED) {
 277             throw new IllegalStateException();
 278         }
 279         return Job.revoke(this);
 280
 281     }
 282
 283     public X509Certificate cert() throws IOException, GeneralSecurityException, SQLException {
 284         CertificateStatus status = getStatus();
 285         if (status != CertificateStatus.ISSUED) {
 286             throw new IllegalStateException(status + " is not wanted here.");
 287         }
 288         InputStream is = null;
 289         X509Certificate crt = null;
 290         try {
 291             is = new FileInputStream(crtName);
 292             CertificateFactory cf = CertificateFactory.getInstance("X.509");
 293             crt = (X509Certificate) cf.generateCertificate(is);
 294         } finally {
 295             if (is != null) {
 296                 is.close();
 297             }
 298         }
 299         return crt;
 300     }
 301
 302     public Certificate renew() {
 303         return null;
 304     }
 305
 306     public int getId() {
 307         return id;
 308     }
 309
 310     public String getSerial() {
 311         try {
 312             getStatus();
 313         } catch (SQLException e) {
 314             e.printStackTrace();
 315         } // poll changes
 316         return serial;
 317     }
 318
 319     public String getDistinguishedName() {
 320         return dn;
 321     }
 322
 323     public String getMessageDigest() {
 324         return md;
 325     }
 326
 327     public int getOwnerId() {
 328         return ownerId;
 329     }
 330
 331     public List<SubjectAlternateName> getSANs() {
 332         return Collections.unmodifiableList(sans);
 333     }
 334
 335     public CertificateProfile getProfile() {
 336         return profile;
 337     }
 338
 339     public static Certificate getBySerial(String serial) {
 340         // TODO caching?
 341         try {
 342             return new Certificate(serial);
 343         } catch (IllegalArgumentException e) {
 344
 345         }
 346         return null;
 347     }
 348
 349 }