Changeset 7ab4dd7


Ignore:
Timestamp:
Sep 12, 2013 8:22:30 PM (7 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
43f5062
Parents:
71c0104
Message:

KeyStoreUtil?:

  • Overwrite check in createKeys()
  • New getCert(), getKey() SU3File:
  • Store generated keys in keystore
  • Get private key for signing from keystore
Location:
core/java/src/net/i2p/crypto
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • core/java/src/net/i2p/crypto/KeyStoreUtil.java

    r71c0104 r7ab4dd7  
    77import java.security.GeneralSecurityException;
    88import java.security.KeyStore;
     9import java.security.PrivateKey;
    910import java.security.cert.Certificate;
    1011import java.security.cert.CertificateException;
     
    253254     *  @param cname e.g. randomstuff.console.i2p.net
    254255     *  @param ou e.g. console
    255      *  @param keqPW the key password
     256     *  @param keyPW the key password, must be at least 6 characters
    256257     *
    257258     *  @return success
     
    277278     *  @param keyAlg e.g. DSA , RSA, EC
    278279     *  @param keySize e.g. 1024
    279      *  @param keqPW the key password
     280     *  @param keyPW the key password, must be at least 6 characters
    280281     *
    281282     *  @return success
     
    284285    public static boolean createKeys(File ks, String ksPW, String alias, String cname, String ou,
    285286                                     int validDays, String keyAlg, int keySize, String keyPW) {
    286         if (!ks.exists()) {
     287        if (ks.exists()) {
     288            try {
     289                if (getCert(ks, ksPW, alias) != null) {
     290                    error("Not overwriting key " + alias + ", already exists in " + ks, null);
     291                    return false;
     292                }
     293            } catch (Exception e) {
     294                error("Not overwriting key \"" + alias + "\", already exists in " + ks, e);
     295                return false;
     296            }
     297        } else {
    287298            File dir = ks.getParentFile();
    288             if (!dir.exists()) {
     299            if (dir != null && !dir.exists()) {
    289300                File sdir = new SecureDirectory(dir.getAbsolutePath());
    290301                if (!sdir.mkdir()) {
     
    320331                buf.append('"').append(args[i]).append("\" ");
    321332            }
    322             error("Failed to create SSL keystore using command line:" + buf, null);
     333            error("Failed to create SSL keystore using command line: " + buf, null);
    323334        }
    324335        return success;
     336    }
     337
     338    /**
     339     *  Get a private key out of a keystore
     340     *
     341     *  @param ks path to the keystore
     342     *  @param ksPW the keystore password, may be null
     343     *  @param alias the name of the key
     344     *  @param keyPW the key password, must be at least 6 characters
     345     *  @return the key or null if not found
     346     */
     347    public static PrivateKey getPrivateKey(File ks, String ksPW, String alias, String keyPW)
     348                              throws GeneralSecurityException, IOException {
     349        InputStream fis = null;
     350        try {
     351            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
     352            fis = new FileInputStream(ks);
     353            char[] pwchars = ksPW != null ? ksPW.toCharArray() : null;
     354            keyStore.load(fis, pwchars);
     355            char[] keypwchars = keyPW.toCharArray();
     356            return (PrivateKey) keyStore.getKey(alias, keypwchars);
     357        } finally {
     358            if (fis != null) try { fis.close(); } catch (IOException ioe) {}
     359        }
     360    }
     361
     362    /**
     363     *  Get a cert out of a keystore
     364     *
     365     *  @param ks path to the keystore
     366     *  @param ksPW the keystore password, may be null
     367     *  @param alias the name of the key
     368     *  @return the certificate or null if not found
     369     */
     370    public static Certificate getCert(File ks, String ksPW, String alias)
     371                              throws GeneralSecurityException, IOException {
     372        InputStream fis = null;
     373        try {
     374            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
     375            fis = new FileInputStream(ks);
     376            char[] pwchars = ksPW != null ? ksPW.toCharArray() : null;
     377            keyStore.load(fis, pwchars);
     378            return keyStore.getCertificate(alias);
     379        } finally {
     380            if (fis != null) try { fis.close(); } catch (IOException ioe) {}
     381        }
    325382    }
    326383
     
    339396        InputStream fis = null;
    340397        try {
    341             KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
    342             fis = new FileInputStream(ks);
    343             char[] pwchars = ksPW != null ? ksPW.toCharArray() : null;
    344             keyStore.load(fis, pwchars);
    345             Certificate cert = keyStore.getCertificate(alias);
     398            Certificate cert = getCert(ks, ksPW, alias);
    346399            if (cert != null)
    347400                return CertUtil.saveCert(cert, certFile);
     
    350403        } catch (IOException ioe) {
    351404            error("Error saving ASCII SSL keys", ioe);
    352         } finally {
    353             if (fis != null) try { fis.close(); } catch (IOException ioe) {}
    354405        }
    355406        return false;
  • core/java/src/net/i2p/crypto/SU3File.java

    r71c0104 r7ab4dd7  
    504504                                         String privateKeyFile, String version, String signerName) {
    505505        try {
     506            String keypw = "";
     507            while (keypw.length() < 6) {
     508                System.out.print("Enter password for key \"" + signerName + "\": ");
     509                keypw = DataHelper.readLine(System.in).trim();
     510                if (keypw.length() > 0 && keypw.length() < 6)
     511                    System.out.println("Key password must be at least 6 characters");
     512            }
    506513            File pkfile = new File(privateKeyFile);
    507             PrivateKey pk = SigUtil.importJavaPrivateKey(pkfile, type);
     514            PrivateKey pk = KeyStoreUtil.getPrivateKey(pkfile,KeyStoreUtil.DEFAULT_KEYSTORE_PASSWORD, signerName, keypw);
    508515            SigningPrivateKey spk = SigUtil.fromJavaKey(pk, type);
    509516            SU3File file = new SU3File(signedFile);
     
    569576    private static final boolean genKeysCLI(SigType type, String publicKeyFile, String privateKeyFile) {
    570577        File pubFile = new File(publicKeyFile);
    571         File privFile = new File(privateKeyFile);
    572578        if (pubFile.exists()) {
    573579            System.out.println("Error: Not overwriting file " + publicKeyFile);
    574580            return false;
    575581        }
    576         if (privFile.exists()) {
    577             System.out.println("Error: Not overwriting file " + privateKeyFile);
    578             return false;
    579         }
    580         FileOutputStream fileOutputStream = null;
    581         I2PAppContext context = I2PAppContext.getGlobalContext();
    582         try {
    583             // inefficiently go from Java to I2P to Java formats
    584             SimpleDataStructure signingKeypair[] = context.keyGenerator().generateSigningKeys(type);
    585             SigningPublicKey signingPublicKey = (SigningPublicKey) signingKeypair[0];
    586             SigningPrivateKey signingPrivateKey = (SigningPrivateKey) signingKeypair[1];
    587             PublicKey pubkey = SigUtil.toJavaKey(signingPublicKey);
    588             PrivateKey privkey = SigUtil.toJavaKey(signingPrivateKey);
    589 
    590             fileOutputStream = new SecureFileOutputStream(pubFile);
    591             fileOutputStream.write(pubkey.getEncoded());
    592             fileOutputStream.close();
    593             fileOutputStream = null;
    594 
    595             fileOutputStream = new SecureFileOutputStream(privFile);
    596             fileOutputStream.write(privkey.getEncoded());
    597 
    598             System.out.println("\r\n" + type + " Private key written to: " + privateKeyFile);
    599             System.out.println(type + " Public key written to: " + publicKeyFile);
    600             System.out.println("\r\nPublic key: " + signingPublicKey.toBase64() + "\r\n");
    601         } catch (Exception e) {
     582        File ksFile = new File(privateKeyFile);
     583        String alias = "";
     584        String keypw = "";
     585        try {
     586            while (alias.length() == 0) {
     587                System.out.print("Enter key name (example@mail.i2p): ");
     588                alias = DataHelper.readLine(System.in).trim();
     589            }
     590            while (keypw.length() < 6) {
     591                System.out.print("Enter new key password: ");
     592                keypw = DataHelper.readLine(System.in).trim();
     593                if (keypw.length() > 0 && keypw.length() < 6)
     594                    System.out.println("Key password must be at least 6 characters");
     595            }
     596        } catch (IOException ioe) {
     597            return false;
     598        }
     599        int keylen = type.getPubkeyLen() * 8;
     600        if (type.getBaseAlgorithm() == SigAlgo.EC) {
     601            keylen /= 2;
     602            if (keylen == 528)
     603                keylen = 521;
     604        }
     605        boolean success = KeyStoreUtil.createKeys(ksFile, KeyStoreUtil.DEFAULT_KEYSTORE_PASSWORD, alias,
     606                                                  "cn", "ou", 3652, type.getBaseAlgorithm().getName(),
     607                                                  keylen, keypw);
     608        if (!success) {
    602609            System.err.println("Error writing keys:");
    603             e.printStackTrace();
    604             return false;
    605         } finally {
    606             if (fileOutputStream != null)
    607                 try {
    608                     fileOutputStream.close();
    609                 } catch (IOException ioe) {}
     610            return false;
     611        }
     612        File outfile = new File(publicKeyFile);
     613        success = KeyStoreUtil.exportCert(ksFile, KeyStoreUtil.DEFAULT_KEYSTORE_PASSWORD, alias, outfile);
     614        if (!success) {
     615            System.err.println("Error writing keys:");
     616            return false;
    610617        }
    611618        return true;
Note: See TracChangeset for help on using the changeset viewer.