Changeset 888ef37


Ignore:
Timestamp:
Jun 24, 2014 2:14:05 AM (7 years ago)
Author:
str4d <str4d@…>
Branches:
master
Children:
2cfe5e6
Parents:
b611d023 (diff), 91408cb (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

propagate from branch 'i2p.i2p' (head 5a3ad2a39b0e0f06e70cb8b4d4f7b1d6461afc1a)

to branch 'i2p.i2p.str4d.eddsa' (head b2a13496a248ebfdac0aa3a8528a27ceff091b6b)

Files:
1 added
8 edited

Legend:

Unmodified
Added
Removed
  • apps/i2ptunnel/jsp/editClient.jsp

    rb611d023 r888ef37  
    513513                <input value="3" type="radio" id="startOnLoad" name="sigType" title="Advanced users only"<%=(editBean.getSigType(curTunnel)==3 ? " checked=\"checked\"" : "")%> class="tickbox" />               
    514514              </div>
     515           <% }
     516              if (editBean.isSigTypeAvailable(7)) { %>
     517              <div id="portField" class="rowItem">
     518                <label>Ed25519-SHA-512</label>
     519                <input value="7" type="radio" id="startOnLoad" name="sigType" title="Advanced users only"<%=(editBean.getSigType(curTunnel)==7 ? " checked=\"checked\"" : "")%> class="tickbox" />               
     520              </div>
    515521           <% }   // isAvailable %>
    516522            </div>
  • apps/i2ptunnel/jsp/editServer.jsp

    rb611d023 r888ef37  
    600600                <input value="3" type="radio" id="startOnLoad" name="sigType" title="Advanced users only"<%=(editBean.getSigType(curTunnel)==3 ? " checked=\"checked\"" : "")%> class="tickbox" />               
    601601              </div>
     602           <% }
     603              if (editBean.isSigTypeAvailable(7)) { %>
     604              <div id="portField" class="rowItem">
     605                <label>Ed25519-SHA-512</label>
     606                <input value="7" type="radio" id="startOnLoad" name="sigType" title="Advanced users only"<%=(editBean.getSigType(curTunnel)==7 ? " checked=\"checked\"" : "")%> class="tickbox" />               
     607              </div>
    602608           <% }   // isAvailable %>
    603609            </div>
  • core/java/src/net/i2p/crypto/DSAEngine.java

    rb611d023 r888ef37  
    4343
    4444import net.i2p.I2PAppContext;
     45import net.i2p.crypto.eddsa.EdDSAKey;
    4546import net.i2p.data.Hash;
    4647import net.i2p.data.Signature;
     
    504505            return altVerifySigSHA1(signature, data, offset, len, verifyingKey);
    505506
    506         java.security.Signature jsig = java.security.Signature.getInstance(type.getAlgorithmName());
     507        java.security.Signature jsig;
     508        if (type.getBaseAlgorithm() == SigAlgo.EdDSA)
     509            jsig = new net.i2p.crypto.eddsa.EdDSAEngine(type.getDigestInstance());
     510        else
     511            jsig = java.security.Signature.getInstance(type.getAlgorithmName());
    507512        PublicKey pubKey = SigUtil.toJavaKey(verifyingKey);
    508513        jsig.initVerify(pubKey);
     
    544549
    545550        String algo = getRawAlgo(type);
    546         java.security.Signature jsig = java.security.Signature.getInstance(algo);
     551        java.security.Signature jsig;
     552        if (type.getBaseAlgorithm() == SigAlgo.EdDSA)
     553            jsig = new net.i2p.crypto.eddsa.EdDSAEngine(); // Ignore algo, EdDSAKey includes a hash specification.
     554        else
     555            jsig = java.security.Signature.getInstance(algo);
    547556        jsig.initVerify(pubKey);
    548557        jsig.update(hash.getData());
     
    581590            return altSignSHA1(data, offset, len, privateKey);
    582591
    583         java.security.Signature jsig = java.security.Signature.getInstance(type.getAlgorithmName());
     592        java.security.Signature jsig;
     593        if (type.getBaseAlgorithm() == SigAlgo.EdDSA)
     594            jsig = new net.i2p.crypto.eddsa.EdDSAEngine(type.getDigestInstance());
     595        else
     596            jsig = java.security.Signature.getInstance(type.getAlgorithmName());
    584597        PrivateKey privKey = SigUtil.toJavaKey(privateKey);
    585598        jsig.initSign(privKey, _context.random());
     
    614627            throw new IllegalArgumentException("type mismatch hash=" + hash.getClass() + " key=" + type);
    615628
    616         java.security.Signature jsig = java.security.Signature.getInstance(algo);
     629        java.security.Signature jsig;
     630        if (type.getBaseAlgorithm() == SigAlgo.EdDSA)
     631            jsig = new net.i2p.crypto.eddsa.EdDSAEngine(); // Ignore algo, EdDSAKey includes a hash specification.
     632        else
     633            jsig = java.security.Signature.getInstance(algo);
    617634        jsig.initSign(privKey, _context.random());
    618635        jsig.update(hash.getData());
     
    641658            case EC:
    642659                return "NONEwithECDSA";
     660            case EdDSA:
     661                return "NONEwithEdDSA";
    643662            case RSA:
    644663                return "NONEwithRSA";
     
    654673        if (key instanceof ECKey)
    655674            return "NONEwithECDSA";
     675        if (key instanceof EdDSAKey)
     676            return "NONEwithEdDSA";
    656677        if (key instanceof RSAKey)
    657678            return "NONEwithRSA";
  • core/java/src/net/i2p/crypto/KeyGenerator.java

    rb611d023 r888ef37  
    217217        if (type == SigType.DSA_SHA1)
    218218            return generateSigningKeys();
    219         KeyPairGenerator kpg = KeyPairGenerator.getInstance(type.getBaseAlgorithm().getName());
    220219        KeyPair kp;
    221         try {
     220        if (type.getBaseAlgorithm() == SigAlgo.EdDSA) {
     221            net.i2p.crypto.eddsa.KeyPairGenerator kpg = new net.i2p.crypto.eddsa.KeyPairGenerator();
    222222            kpg.initialize(type.getParams(), _context.random());
    223223            kp = kpg.generateKeyPair();
    224         } catch (ProviderException pe) {
    225             // java.security.ProviderException: sun.security.pkcs11.wrapper.PKCS11Exception: CKR_DOMAIN_PARAMS_INVALID
    226             // This is a RuntimeException, thx Sun
    227             // Fails for P-192 only, on Ubuntu
    228             Log log = _context.logManager().getLog(KeyGenerator.class);
    229             String pname = kpg.getProvider().getName();
    230             if ("BC".equals(pname)) {
    231                 if (log.shouldLog(Log.WARN))
    232                     log.warn("BC KPG failed for " + type, pe);
    233                 throw new GeneralSecurityException("BC KPG for " + type, pe);
    234             }
    235             if (!ECConstants.isBCAvailable())
    236                 throw new GeneralSecurityException(pname + " KPG failed for " + type, pe);
    237             if (log.shouldLog(Log.WARN))
    238                 log.warn(pname + " KPG failed for " + type + ", trying BC"  /* , pe */ );
     224        } else {
     225            KeyPairGenerator kpg = KeyPairGenerator.getInstance(type.getBaseAlgorithm().getName());
    239226            try {
    240                 kpg = KeyPairGenerator.getInstance(type.getBaseAlgorithm().getName(), "BC");
    241227                kpg.initialize(type.getParams(), _context.random());
    242228                kp = kpg.generateKeyPair();
    243             } catch (ProviderException pe2) {
     229            } catch (ProviderException pe) {
     230                // java.security.ProviderException: sun.security.pkcs11.wrapper.PKCS11Exception: CKR_DOMAIN_PARAMS_INVALID
     231                // This is a RuntimeException, thx Sun
     232                // Fails for P-192 only, on Ubuntu
     233                Log log = _context.logManager().getLog(KeyGenerator.class);
     234                String pname = kpg.getProvider().getName();
     235                if ("BC".equals(pname)) {
     236                    if (log.shouldLog(Log.WARN))
     237                        log.warn("BC KPG failed for " + type, pe);
     238                    throw new GeneralSecurityException("BC KPG for " + type, pe);
     239                }
     240                if (!ECConstants.isBCAvailable())
     241                    throw new GeneralSecurityException(pname + " KPG failed for " + type, pe);
    244242                if (log.shouldLog(Log.WARN))
    245                     log.warn("BC KPG failed for " + type + " also", pe2);
    246                 // throw original exception
    247                 throw new GeneralSecurityException(pname + " KPG for " + type, pe);
    248             } catch (GeneralSecurityException gse) {
    249                 if (log.shouldLog(Log.WARN))
    250                     log.warn("BC KPG failed for " + type + " also", gse);
    251                 // throw original exception
    252                 throw new GeneralSecurityException(pname + " KPG for " + type, pe);
     243                    log.warn(pname + " KPG failed for " + type + ", trying BC"  /* , pe */ );
     244                try {
     245                    kpg = KeyPairGenerator.getInstance(type.getBaseAlgorithm().getName(), "BC");
     246                    kpg.initialize(type.getParams(), _context.random());
     247                    kp = kpg.generateKeyPair();
     248                } catch (ProviderException pe2) {
     249                    if (log.shouldLog(Log.WARN))
     250                        log.warn("BC KPG failed for " + type + " also", pe2);
     251                    // throw original exception
     252                    throw new GeneralSecurityException(pname + " KPG for " + type, pe);
     253                } catch (GeneralSecurityException gse) {
     254                    if (log.shouldLog(Log.WARN))
     255                        log.warn("BC KPG failed for " + type + " also", gse);
     256                    // throw original exception
     257                    throw new GeneralSecurityException(pname + " KPG for " + type, pe);
     258                }
    253259            }
    254260        }
  • core/java/src/net/i2p/crypto/SU3File.java

    rb611d023 r888ef37  
    516516        buf.append("Available signature types:\n");
    517517        for (SigType t : EnumSet.allOf(SigType.class)) {
     518            if (!t.isAvailable())
     519                continue;
     520            if (t == SigType.EdDSA_SHA512_25519)
     521                continue; // not supported by keytool, and does double hashing right now
    518522            buf.append("      ").append(t).append("\t(code: ").append(t.getCode()).append(')');
    519523            if (t.getCode() == DEFAULT_SIG_CODE)
  • core/java/src/net/i2p/crypto/SigAlgo.java

    rb611d023 r888ef37  
    1010    DSA("DSA"),
    1111    EC("EC"),
     12    EdDSA("EdDSA"),
    1213    RSA("RSA")
    1314    ;
  • core/java/src/net/i2p/crypto/SigType.java

    rb611d023 r888ef37  
    1010import java.util.Map;
    1111
     12import net.i2p.crypto.eddsa.spec.EdDSANamedCurveTable;
    1213import net.i2p.data.Hash;
    1314import net.i2p.data.SimpleDataStructure;
     
    4849    // TESTING....................
    4950
    50 
     51    /** Pubkey 32 bytes; privkey 32 bytes; hash 64 bytes; sig 64 bytes; */
     52    EdDSA_SHA512_25519(7, 32, 32, 64, 64, SigAlgo.EdDSA, "SHA-512", "SHA512withEdDSA", EdDSANamedCurveTable.getByName("ed25519-sha-512"));
    5153
    5254    // others..........
     
    170172        try {
    171173            getParams();
    172             Signature.getInstance(getAlgorithmName());
     174            if (getBaseAlgorithm() != SigAlgo.EdDSA)
     175                Signature.getInstance(getAlgorithmName());
    173176            getDigestInstance();
    174177            getHashInstance();
  • core/java/src/net/i2p/crypto/SigUtil.java

    rb611d023 r888ef37  
    66import java.io.InputStream;
    77import java.io.IOException;
    8 
    98import java.math.BigInteger;
    109import java.security.GeneralSecurityException;
     
    3433import java.util.Map;
    3534
     35import net.i2p.crypto.eddsa.EdDSAPrivateKey;
     36import net.i2p.crypto.eddsa.EdDSAPublicKey;
     37import net.i2p.crypto.eddsa.spec.EdDSAParameterSpec;
     38import net.i2p.crypto.eddsa.spec.EdDSAPrivateKeySpec;
     39import net.i2p.crypto.eddsa.spec.EdDSAPublicKeySpec;
    3640import net.i2p.data.Signature;
    3741import net.i2p.data.SigningPrivateKey;
     
    4852public class SigUtil {
    4953
    50     private static final Map<SigningPublicKey, ECPublicKey> _pubkeyCache = new LHMCache<SigningPublicKey, ECPublicKey>(64);
    51     private static final Map<SigningPrivateKey, ECPrivateKey> _privkeyCache = new LHMCache<SigningPrivateKey, ECPrivateKey>(16);
     54    private static final Map<SigningPublicKey, ECPublicKey> _ECPubkeyCache = new LHMCache<SigningPublicKey, ECPublicKey>(64);
     55    private static final Map<SigningPrivateKey, ECPrivateKey> _ECPrivkeyCache = new LHMCache<SigningPrivateKey, ECPrivateKey>(16);
     56    private static final Map<SigningPublicKey, EdDSAPublicKey> _EdPubkeyCache = new LHMCache<SigningPublicKey, EdDSAPublicKey>(64);
     57    private static final Map<SigningPrivateKey, EdDSAPrivateKey> _EdPrivkeyCache = new LHMCache<SigningPrivateKey, EdDSAPrivateKey>(16);
    5258
    5359    private SigUtil() {}
     
    6369            case EC:
    6470                return toJavaECKey(pk);
     71            case EdDSA:
     72                return toJavaEdDSAKey(pk);
    6573            case RSA:
    6674                return toJavaRSAKey(pk);
     
    8088            case EC:
    8189                return toJavaECKey(pk);
     90            case EdDSA:
     91                return toJavaEdDSAKey(pk);
    8292            case RSA:
    8393                return toJavaRSAKey(pk);
     
    97107            case EC:
    98108                return fromJavaKey((ECPublicKey) pk, type);
     109            case EdDSA:
     110                return fromJavaKey((EdDSAPublicKey) pk, type);
    99111            case RSA:
    100112                return fromJavaKey((RSAPublicKey) pk, type);
     
    114126            case EC:
    115127                return fromJavaKey((ECPrivateKey) pk, type);
     128            case EdDSA:
     129                return fromJavaKey((EdDSAPrivateKey) pk, type);
    116130            case RSA:
    117131                return fromJavaKey((RSAPrivateKey) pk, type);
     
    127141                              throws GeneralSecurityException {
    128142        ECPublicKey rv;
    129         synchronized (_pubkeyCache) {
    130             rv = _pubkeyCache.get(pk);
     143        synchronized (_ECPubkeyCache) {
     144            rv = _ECPubkeyCache.get(pk);
    131145        }
    132146        if (rv != null)
    133147            return rv;
    134148        rv = cvtToJavaECKey(pk);
    135         synchronized (_pubkeyCache) {
    136             _pubkeyCache.put(pk, rv);
     149        synchronized (_ECPubkeyCache) {
     150            _ECPubkeyCache.put(pk, rv);
    137151        }
    138152        return rv;
     
    145159                              throws GeneralSecurityException {
    146160        ECPrivateKey rv;
    147         synchronized (_privkeyCache) {
    148             rv = _privkeyCache.get(pk);
     161        synchronized (_ECPrivkeyCache) {
     162            rv = _ECPrivkeyCache.get(pk);
    149163        }
    150164        if (rv != null)
    151165            return rv;
    152166        rv = cvtToJavaECKey(pk);
    153         synchronized (_privkeyCache) {
    154             _privkeyCache.put(pk, rv);
     167        synchronized (_ECPrivkeyCache) {
     168            _ECPrivkeyCache.put(pk, rv);
    155169        }
    156170        return rv;
     
    197211    }
    198212
     213    /**
     214     *  @return JAVA EdDSA public key!
     215     */
     216    public static EdDSAPublicKey toJavaEdDSAKey(SigningPublicKey pk)
     217                              throws GeneralSecurityException {
     218        EdDSAPublicKey rv;
     219        synchronized (_EdPubkeyCache) {
     220            rv = _EdPubkeyCache.get(pk);
     221        }
     222        if (rv != null)
     223            return rv;
     224        rv = cvtToJavaEdDSAKey(pk);
     225        synchronized (_EdPubkeyCache) {
     226            _EdPubkeyCache.put(pk, rv);
     227        }
     228        return rv;
     229    }
     230
     231    /**
     232     *  @return JAVA EdDSA private key!
     233     */
     234    public static EdDSAPrivateKey toJavaEdDSAKey(SigningPrivateKey pk)
     235                              throws GeneralSecurityException {
     236        EdDSAPrivateKey rv;
     237        synchronized (_EdPrivkeyCache) {
     238            rv = _EdPrivkeyCache.get(pk);
     239        }
     240        if (rv != null)
     241            return rv;
     242        rv = cvtToJavaEdDSAKey(pk);
     243        synchronized (_EdPrivkeyCache) {
     244            _EdPrivkeyCache.put(pk, rv);
     245        }
     246        return rv;
     247    }
     248
     249    private static EdDSAPublicKey cvtToJavaEdDSAKey(SigningPublicKey pk)
     250                              throws GeneralSecurityException {
     251        try {
     252            return new EdDSAPublicKey(new EdDSAPublicKeySpec(
     253                pk.getData(), (EdDSAParameterSpec) pk.getType().getParams()));
     254        } catch (IllegalArgumentException iae) {
     255            throw new InvalidKeyException(iae);
     256        }
     257    }
     258
     259    private static EdDSAPrivateKey cvtToJavaEdDSAKey(SigningPrivateKey pk)
     260                              throws GeneralSecurityException {
     261        try {
     262            return new EdDSAPrivateKey(new EdDSAPrivateKeySpec(
     263                pk.getData(), (EdDSAParameterSpec) pk.getType().getParams()));
     264        } catch (IllegalArgumentException iae) {
     265            throw new InvalidKeyException(iae);
     266        }
     267    }
     268
     269    public static SigningPublicKey fromJavaKey(EdDSAPublicKey pk, SigType type)
     270            throws GeneralSecurityException {
     271        return new SigningPublicKey(type, pk.getAbyte());
     272    }
     273
     274    public static SigningPrivateKey fromJavaKey(EdDSAPrivateKey pk, SigType type)
     275            throws GeneralSecurityException {
     276        return new SigningPrivateKey(type, pk.getSeed());
     277    }
     278
    199279    public static DSAPublicKey toJavaDSAKey(SigningPublicKey pk)
    200280                              throws GeneralSecurityException {
     
    291371     */
    292372    public static byte[] toJavaSig(Signature sig) {
    293         // RSA sigs are not ASN encoded
    294         if (sig.getType().getBaseAlgorithm() == SigAlgo.RSA)
     373        // RSA and EdDSA sigs are not ASN encoded
     374        if (sig.getType().getBaseAlgorithm() == SigAlgo.RSA || sig.getType().getBaseAlgorithm() == SigAlgo.EdDSA)
    295375            return sig.getData();
    296376        return sigBytesToASN1(sig.getData());
     
    303383    public static Signature fromJavaSig(byte[] asn, SigType type)
    304384                              throws SignatureException {
    305         // RSA sigs are not ASN encoded
    306         if (type.getBaseAlgorithm() == SigAlgo.RSA)
     385        // RSA and EdDSA sigs are not ASN encoded
     386        if (type.getBaseAlgorithm() == SigAlgo.RSA || type.getBaseAlgorithm() == SigAlgo.EdDSA)
    307387            return new Signature(type, asn);
    308388        return new Signature(type, aSN1ToSigBytes(asn, type.getSigLen()));
     
    531611
    532612    public static void clearCaches() {
    533         synchronized(_pubkeyCache) {
    534             _pubkeyCache.clear();
    535         }
    536         synchronized(_privkeyCache) {
    537             _privkeyCache.clear();
     613        synchronized(_ECPubkeyCache) {
     614            _ECPubkeyCache.clear();
     615        }
     616        synchronized(_ECPrivkeyCache) {
     617            _ECPrivkeyCache.clear();
     618        }
     619        synchronized(_EdPubkeyCache) {
     620            _EdPubkeyCache.clear();
     621        }
     622        synchronized(_EdPrivkeyCache) {
     623            _EdPrivkeyCache.clear();
    538624        }
    539625    }
Note: See TracChangeset for help on using the changeset viewer.