Changeset e65c2e2


Ignore:
Timestamp:
May 29, 2009 10:00:06 AM (11 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
7f33051f
Parents:
b43338bd
Message:
Files:
2 deleted
5 edited

Legend:

Unmodified
Added
Removed
  • core/java/src/net/i2p/I2PAppContext.java

    rb43338bd re65c2e2  
    1818import net.i2p.crypto.HMACGenerator;
    1919import net.i2p.crypto.KeyGenerator;
    20 import net.i2p.crypto.PersistentSessionKeyManager;
    2120import net.i2p.crypto.SHA256Generator;
    2221import net.i2p.crypto.SessionKeyManager;
     22import net.i2p.crypto.TransientSessionKeyManager;
    2323import net.i2p.data.RoutingKeyGenerator;
    2424import net.i2p.stat.StatManager;
     
    257257        synchronized (this) {
    258258            if (_sessionKeyManager == null)
    259                 _sessionKeyManager = new PersistentSessionKeyManager(this);
     259                //_sessionKeyManager = new PersistentSessionKeyManager(this);
     260                _sessionKeyManager = new TransientSessionKeyManager(this);
    260261            _sessionKeyManagerInitialized = true;
    261262        }
  • core/java/src/net/i2p/crypto/ElGamalAESEngine.java

    rb43338bd re65c2e2  
    6060
    6161    /**
     62     * Decrypt the message using the given private key using tags from the given key manager.
     63     */
     64    public byte[] decrypt(byte data[], PrivateKey targetPrivateKey) throws DataFormatException {
     65        return decrypt(data, targetPrivateKey, _context.sessionKeyManager());
     66    }
     67
     68    /**
    6269     * Decrypt the message using the given private key.  This works according to the
    6370     * ElGamal+AES algorithm in the data structure spec.
    6471     *
    6572     */
    66     public byte[] decrypt(byte data[], PrivateKey targetPrivateKey) throws DataFormatException {
     73    public byte[] decrypt(byte data[], PrivateKey targetPrivateKey, SessionKeyManager keyManager) throws DataFormatException {
    6774        if (data == null) {
    6875            if (_log.shouldLog(Log.ERROR)) _log.error("Null data being decrypted?");
     
    7784        System.arraycopy(data, 0, tag, 0, tag.length);
    7885        SessionTag st = new SessionTag(tag);
    79         SessionKey key = _context.sessionKeyManager().consumeTag(st);
     86        SessionKey key = keyManager.consumeTag(st);
    8087        SessionKey foundKey = new SessionKey();
    8188        foundKey.setData(null);
     
    125132                if (_log.shouldLog(Log.DEBUG))
    126133                    _log.debug("Found key: " + foundKey.toBase64() + " tags: " + foundTags + " wasExisting? " + wasExisting);
    127                 _context.sessionKeyManager().tagsReceived(foundKey, foundTags);
     134                keyManager.tagsReceived(foundKey, foundTags);
    128135            } else {
    129136                if (_log.shouldLog(Log.DEBUG))
    130137                    _log.debug("Used key: " + usedKey.toBase64() + " tags: " + foundTags + " wasExisting? " + wasExisting);
    131                 _context.sessionKeyManager().tagsReceived(usedKey, foundTags);
     138                keyManager.tagsReceived(usedKey, foundTags);
    132139            }
    133140        }
  • core/java/src/net/i2p/crypto/SessionKeyManager.java

    rb43338bd re65c2e2  
    9494     *
    9595     */
    96     public void tagsDelivered(PublicKey target, SessionKey key, Set sessionTags) { // nop
     96    public void tagsDelivered(PublicKey target, SessionKey key, Set<SessionTag> sessionTags) { // nop
    9797    }
    9898
     
    110110     *
    111111     */
    112     public void tagsReceived(SessionKey key, Set sessionTags) { // nop
     112    public void tagsReceived(SessionKey key, Set<SessionTag> sessionTags) { // nop
    113113    }
    114114
  • core/java/src/net/i2p/crypto/TransientSessionKeyManager.java

    rb43338bd re65c2e2  
    3434 *
    3535 */
    36 class TransientSessionKeyManager extends SessionKeyManager {
     36public class TransientSessionKeyManager extends SessionKeyManager {
    3737    private Log _log;
    3838    /** Map allowing us to go from the targeted PublicKey to the OutboundSession used */
    39     private Map _outboundSessions;
     39    private Map<PublicKey, OutboundSession> _outboundSessions;
    4040    /** Map allowing us to go from a SessionTag to the containing TagSet */
    41     private Map _inboundTagSets;
     41    private Map<SessionTag, TagSet> _inboundTagSets;
    4242    protected I2PAppContext _context;
    4343
     
    5656     */
    5757    public final static long SESSION_LIFETIME_MAX_MS = SESSION_TAG_DURATION_MS + 5 * 60 * 1000;
     58    /**
     59     * a few MB? how about 16MB!
     60     * This is the max size of _inboundTagSets.
     61     */
    5862    public final static int MAX_INBOUND_SESSION_TAGS = 500 * 1000; // this will consume at most a few MB
    5963
     
    6872        _log = context.logManager().getLog(TransientSessionKeyManager.class);
    6973        _context = context;
    70         _outboundSessions = new HashMap(1024);
     74        _outboundSessions = new HashMap(64);
    7175        _inboundTagSets = new HashMap(1024);
    7276        context.statManager().createRateStat("crypto.sessionTagsExpired", "How many tags/sessions are expired?", "Encryption", new long[] { 10*60*1000, 60*60*1000, 3*60*60*1000 });
     
    8690
    8791    /** TagSet */
    88     protected Set getInboundTagSets() {
     92    protected Set<TagSet> getInboundTagSets() {
    8993        synchronized (_inboundTagSets) {
    9094            return new HashSet(_inboundTagSets.values());
     
    9397
    9498    /** OutboundSession */
    95     protected Set getOutboundSessions() {
     99    protected Set<OutboundSession> getOutboundSessions() {
    96100        synchronized (_outboundSessions) {
    97101            return new HashSet(_outboundSessions.values());
     
    99103    }
    100104
    101     protected void setData(Set inboundTagSets, Set outboundSessions) {
     105    protected void setData(Set<TagSet> inboundTagSets, Set<OutboundSession> outboundSessions) {
    102106        if (_log.shouldLog(Log.INFO))
    103107            _log.info("Loading " + inboundTagSets.size() + " inbound tag sets, and "
    104108                      + outboundSessions.size() + " outbound sessions");
    105         Map tagSets = new HashMap(inboundTagSets.size());
    106         for (Iterator iter = inboundTagSets.iterator(); iter.hasNext();) {
    107             TagSet ts = (TagSet) iter.next();
    108             for (Iterator tsIter = ts.getTags().iterator(); tsIter.hasNext();) {
    109                 SessionTag tag = (SessionTag) tsIter.next();
     109        Map<SessionTag, TagSet> tagSets = new HashMap(inboundTagSets.size());
     110        for (Iterator<TagSet> iter = inboundTagSets.iterator(); iter.hasNext();) {
     111            TagSet ts = iter.next();
     112            for (Iterator<SessionTag> tsIter = ts.getTags().iterator(); tsIter.hasNext();) {
     113                SessionTag tag = tsIter.next();
    110114                tagSets.put(tag, ts);
    111115            }
     
    115119            _inboundTagSets.putAll(tagSets);
    116120        }
    117         Map sessions = new HashMap(outboundSessions.size());
    118         for (Iterator iter = outboundSessions.iterator(); iter.hasNext();) {
    119             OutboundSession sess = (OutboundSession) iter.next();
     121        Map<PublicKey, OutboundSession> sessions = new HashMap(outboundSessions.size());
     122        for (Iterator<OutboundSession> iter = outboundSessions.iterator(); iter.hasNext();) {
     123            OutboundSession sess = iter.next();
    120124            sessions.put(sess.getTarget(), sess);
    121125        }
     
    152156     * when to expire that key begin with this call.
    153157     *
     158     * Unused except in tests?
    154159     */
    155160    @Override
     
    158163        sess.setCurrentKey(key);
    159164        addSession(sess);
     165    }
     166
     167    /**
     168     * Same as above but for internal use, returns OutboundSession so we don't have
     169     * to do a subsequent getSession()
     170     *
     171     */
     172    private OutboundSession createAndReturnSession(PublicKey target, SessionKey key) {
     173        OutboundSession sess = new OutboundSession(target);
     174        sess.setCurrentKey(key);
     175        addSession(sess);
     176        return sess;
    160177    }
    161178
     
    233250        }
    234251        OutboundSession sess = getSession(target);
    235         if (sess == null) {
    236             createSession(target, key);
    237             sess = getSession(target);
    238         }
     252        if (sess == null)
     253            sess = createAndReturnSession(target, key);
    239254        sess.setCurrentKey(key);
    240255        TagSet set = new TagSet(sessionTags, key, _context.clock().now());
     
    258273     */
    259274    @Override
    260     public void tagsReceived(SessionKey key, Set sessionTags) {
     275    public void tagsReceived(SessionKey key, Set<SessionTag> sessionTags) {
    261276        int overage = 0;
    262277        TagSet tagSet = new TagSet(sessionTags, key, _context.clock().now());
    263278        TagSet old = null;
    264279        SessionTag dupTag = null;
    265         for (Iterator iter = sessionTags.iterator(); iter.hasNext();) {
    266             SessionTag tag = (SessionTag) iter.next();
     280        for (Iterator<SessionTag> iter = sessionTags.iterator(); iter.hasNext();) {
     281            SessionTag tag = iter.next();
    267282            if (_log.shouldLog(Log.DEBUG))
    268283                _log.debug("Receiving tag " + tag + " for key " + key.toBase64() + " / " + key.toString() + ": tagSet: " + tagSet);
     
    285300            // drop both old and tagSet tags
    286301            synchronized (_inboundTagSets) {
    287                 for (Iterator iter = old.getTags().iterator(); iter.hasNext(); ) {
    288                     SessionTag tag = (SessionTag)iter.next();
     302                for (Iterator<SessionTag> iter = old.getTags().iterator(); iter.hasNext(); ) {
     303                    SessionTag tag = iter.next();
    289304                    _inboundTagSets.remove(tag);
    290305                }
    291                 for (Iterator iter = sessionTags.iterator(); iter.hasNext(); ) {
    292                     SessionTag tag = (SessionTag)iter.next();
     306                for (Iterator<SessionTag> iter = sessionTags.iterator(); iter.hasNext(); ) {
     307                    SessionTag tag = iter.next();
    293308                    _inboundTagSets.remove(tag);
    294309                }
     
    327342        int toRemove = overage * 2;
    328343        _log.log(Log.CRIT, "TOO MANY SESSION TAGS! Starting cleanup, overage = " + overage);
    329         List removed = new ArrayList(toRemove);
     344        List<TagSet> removed = new ArrayList(toRemove);
    330345        synchronized (_inboundTagSets) {
    331             for (Iterator iter = _inboundTagSets.values().iterator(); iter.hasNext(); ) {
    332                 TagSet set = (TagSet)iter.next();
     346            for (Iterator<TagSet> iter = _inboundTagSets.values().iterator(); iter.hasNext(); ) {
     347                TagSet set = iter.next();
    333348                int size = set.getTags().size();
    334349                if (size > 1000)
     
    346361            for (int i = 0; i < removed.size(); i++) {
    347362                TagSet cur = (TagSet)removed.get(i);
    348                 for (Iterator iter = cur.getTags().iterator(); iter.hasNext(); ) {
    349                     SessionTag tag = (SessionTag)iter.next();
     363                for (Iterator<SessionTag> iter = cur.getTags().iterator(); iter.hasNext(); ) {
     364                    SessionTag tag = iter.next();
    350365                    _inboundTagSets.remove(tag);
    351366                    tags++;
     
    430445        }
    431446        synchronized (_inboundTagSets) {
    432             for (Iterator iter = _inboundTagSets.keySet().iterator(); iter.hasNext();) {
    433                 SessionTag tag = (SessionTag) iter.next();
    434                 TagSet ts = (TagSet) _inboundTagSets.get(tag);
     447            for (Iterator<SessionTag> iter = _inboundTagSets.keySet().iterator(); iter.hasNext();) {
     448                SessionTag tag = iter.next();
     449                TagSet ts = _inboundTagSets.get(tag);
    435450                long age = now - ts.getDate();
    436451                if (age > SESSION_LIFETIME_MAX_MS) {
     
    456471
    457472        synchronized (_outboundSessions) {
    458             for (Iterator iter = _outboundSessions.keySet().iterator(); iter.hasNext();) {
    459                 PublicKey key = (PublicKey) iter.next();
    460                 OutboundSession sess = (OutboundSession) _outboundSessions.get(key);
     473            for (Iterator<PublicKey> iter = _outboundSessions.keySet().iterator(); iter.hasNext();) {
     474                PublicKey key = iter.next();
     475                OutboundSession sess = _outboundSessions.get(key);
    461476                removed += sess.expireTags();
    462477                if (sess.availableTags() <= 0) {
     
    473488        buf.append("<h2>Inbound sessions</h2>");
    474489        buf.append("<table border=\"1\">");
    475         Set inbound = getInboundTagSets();
    476         Map inboundSets = new HashMap(inbound.size());
    477         for (Iterator iter = inbound.iterator(); iter.hasNext();) {
    478             TagSet ts = (TagSet) iter.next();
     490        Set<TagSet> inbound = getInboundTagSets();
     491        Map<SessionKey, Set<TagSet>> inboundSets = new HashMap(inbound.size());
     492        for (Iterator<TagSet> iter = inbound.iterator(); iter.hasNext();) {
     493            TagSet ts = iter.next();
    479494            if (!inboundSets.containsKey(ts.getAssociatedKey())) inboundSets.put(ts.getAssociatedKey(), new HashSet());
    480             Set sets = (Set) inboundSets.get(ts.getAssociatedKey());
     495            Set<TagSet> sets = inboundSets.get(ts.getAssociatedKey());
    481496            sets.add(ts);
    482497        }
    483         for (Iterator iter = inboundSets.keySet().iterator(); iter.hasNext();) {
    484             SessionKey skey = (SessionKey) iter.next();
    485             Set sets = (Set) inboundSets.get(skey);
     498        for (Iterator<SessionKey> iter = inboundSets.keySet().iterator(); iter.hasNext();) {
     499            SessionKey skey = iter.next();
     500            Set<TagSet> sets = inboundSets.get(skey);
    486501            buf.append("<tr><td><b>Session key</b>: ").append(skey.toBase64()).append("</td>");
    487502            buf.append("<td><b># Sets:</b> ").append(sets.size()).append("</td></tr>");
    488503            buf.append("<tr><td colspan=\"2\"><ul>");
    489             for (Iterator siter = sets.iterator(); siter.hasNext();) {
    490                 TagSet ts = (TagSet) siter.next();
     504            for (Iterator<TagSet> siter = sets.iterator(); siter.hasNext();) {
     505                TagSet ts = siter.next();
    491506                buf.append("<li><b>Received on:</b> ").append(new Date(ts.getDate())).append(" with ")
    492507                   .append(ts.getTags().size()).append(" tags remaining</li>");
     
    499514
    500515        buf.append("<table border=\"1\">");
    501         Set outbound = getOutboundSessions();
    502         for (Iterator iter = outbound.iterator(); iter.hasNext();) {
    503             OutboundSession sess = (OutboundSession) iter.next();
     516        Set<OutboundSession> outbound = getOutboundSessions();
     517        for (Iterator<OutboundSession> iter = outbound.iterator(); iter.hasNext();) {
     518            OutboundSession sess = iter.next();
    504519            buf.append("<tr><td><b>Target key:</b> ").append(sess.getTarget().toString()).append("<br />");
    505520            buf.append("<b>Established:</b> ").append(new Date(sess.getEstablishedDate())).append("<br />");
     
    508523            buf.append("<tr><td><b>Session key:</b> ").append(sess.getCurrentKey().toBase64()).append("</td></tr>");
    509524            buf.append("<tr><td><ul>");
    510             for (Iterator siter = sess.getTagSets().iterator(); siter.hasNext();) {
    511                 TagSet ts = (TagSet) siter.next();
     525            for (Iterator<TagSet> siter = sess.getTagSets().iterator(); siter.hasNext();) {
     526                TagSet ts = siter.next();
    512527                buf.append("<li><b>Sent on:</b> ").append(new Date(ts.getDate())).append(" with ").append(
    513528                                                                                                          ts.getTags()
     
    527542        private long _established;
    528543        private long _lastUsed;
    529         private List _tagSets;
     544        private List<TagSet> _tagSets;
    530545
    531546        public OutboundSession(PublicKey target) {
     
    533548        }
    534549
    535         OutboundSession(PublicKey target, SessionKey curKey, long established, long lastUsed, List tagSets) {
     550        OutboundSession(PublicKey target, SessionKey curKey, long established, long lastUsed, List<TagSet> tagSets) {
    536551            _target = target;
    537552            _currentKey = curKey;
     
    542557
    543558        /** list of TagSet objects */
    544         List getTagSets() {
     559        List<TagSet> getTagSets() {
    545560            synchronized (_tagSets) {
    546561                return new ArrayList(_tagSets);
     
    561576                if (!_currentKey.equals(key)) {
    562577                    int dropped = 0;
    563                     List sets = _tagSets;
     578                    List<TagSet> sets = _tagSets;
    564579                    _tagSets = new ArrayList();
    565580                    for (int i = 0; i < sets.size(); i++) {
     
    643658            long last = 0;
    644659            synchronized (_tagSets) {
    645                 for (Iterator iter = _tagSets.iterator(); iter.hasNext();) {
    646                     TagSet set = (TagSet) iter.next();
     660                for (Iterator<TagSet> iter = _tagSets.iterator(); iter.hasNext();) {
     661                    TagSet set = iter.next();
    647662                    if ( (set.getDate() > last) && (set.getTags().size() > 0) )
    648663                        last = set.getDate();
     
    664679
    665680    static class TagSet {
    666         private Set _sessionTags;
     681        private Set<SessionTag> _sessionTags;
    667682        private SessionKey _key;
    668683        private long _date;
    669684        private Exception _createdBy;
    670685
    671         public TagSet(Set tags, SessionKey key, long date) {
     686        public TagSet(Set<SessionTag> tags, SessionKey key, long date) {
    672687            if (key == null) throw new IllegalArgumentException("Missing key");
    673688            if (tags == null) throw new IllegalArgumentException("Missing tags");
     
    693708
    694709        /** tags still available */
    695         public Set getTags() {
     710        public Set<SessionTag> getTags() {
    696711            return _sessionTags;
    697712        }
  • router/java/src/net/i2p/router/Router.java

    rb43338bd re65c2e2  
    5858    private long _started;
    5959    private boolean _higherVersionSeen;
    60     private SessionKeyPersistenceHelper _sessionKeyPersistenceHelper;
     60    //private SessionKeyPersistenceHelper _sessionKeyPersistenceHelper;
    6161    private boolean _killVMOnEnd;
    6262    private boolean _isAlive;
     
    145145        _log = _context.logManager().getLog(Router.class);
    146146        _log.info("New router created with config file " + _configFilename);
    147         _sessionKeyPersistenceHelper = new SessionKeyPersistenceHelper(_context);
     147        //_sessionKeyPersistenceHelper = new SessionKeyPersistenceHelper(_context);
    148148        _killVMOnEnd = true;
    149149        _oomListener = new I2PThread.OOMEventListener() {
     
    262262        _context.jobQueue().addJob(new UpdateRoutingKeyModifierJob(_context));
    263263        warmupCrypto();
    264         _sessionKeyPersistenceHelper.startup();
     264        //_sessionKeyPersistenceHelper.startup();
    265265        //_context.adminManager().startup();
    266266        _context.blocklist().startup();
     
    814814        try { _context.messageValidator().shutdown(); } catch (Throwable t) { _log.log(Log.CRIT, "Error shutting down the message validator", t); }
    815815        try { _context.inNetMessagePool().shutdown(); } catch (Throwable t) { _log.log(Log.CRIT, "Error shutting down the inbound net pool", t); }
    816         try { _sessionKeyPersistenceHelper.shutdown(); } catch (Throwable t) { _log.log(Log.CRIT, "Error shutting down the session key manager", t); }
     816        //try { _sessionKeyPersistenceHelper.shutdown(); } catch (Throwable t) { _log.log(Log.CRIT, "Error shutting down the session key manager", t); }
    817817        RouterContext.listContexts().remove(_context);
    818818        dumpStats();
Note: See TracChangeset for help on using the changeset viewer.