Changeset 636016d1 for router


Ignore:
Timestamp:
Feb 7, 2019 2:54:56 PM (16 months ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
7544d0a
Parents:
b310c60
Message:

NTCP: Add option to disable NTCP1 (ticket #2328)
Don't bid for outbound-only NTCP2 addresses
Fix NTCP2 cost when transitioning to inbound

Location:
router/java/src/net/i2p/router
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • router/java/src/net/i2p/router/RouterVersion.java

    rb310c60 r636016d1  
    1919    public final static String ID = "Monotone";
    2020    public final static String VERSION = CoreVersion.VERSION;
    21     public final static long BUILD = 6;
     21    public final static long BUILD = 7;
    2222
    2323    /** for example "-test" */
  • router/java/src/net/i2p/router/transport/TransportManager.java

    rb310c60 r636016d1  
    7171    private final DHSessionKeyBuilder.PrecalcRunner _dhThread;
    7272    private final X25519KeyFactory _xdhThread;
     73    private final boolean _enableUDP;
     74    private final boolean _enableNTCP1;
    7375
    7476    /** default true */
     
    7981    public final static String PROP_ENABLE_UPNP = "i2np.upnp.enable";
    8082
     83    /** default true */
     84    private static final String PROP_NTCP1_ENABLE = "i2np.ntcp1.enable";
     85    private static final boolean DEFAULT_NTCP1_ENABLE = true;
    8186    private static final String PROP_NTCP2_ENABLE = "i2np.ntcp2.enable";
    8287    private static final boolean DEFAULT_NTCP2_ENABLE = true;
     
    103108        else
    104109            _upnpManager = null;
    105         _dhThread = new DHSessionKeyBuilder.PrecalcRunner(context);
     110        _enableUDP = _context.getBooleanPropertyDefaultTrue(PROP_ENABLE_UDP);
     111        _enableNTCP1 = isNTCPEnabled(context) &&
     112                       context.getProperty(PROP_NTCP1_ENABLE, DEFAULT_NTCP1_ENABLE);
    106113        boolean enableNTCP2 = isNTCPEnabled(context) &&
    107114                              context.getProperty(PROP_NTCP2_ENABLE, DEFAULT_NTCP2_ENABLE);
     115        _dhThread = (_enableUDP || enableNTCP2) ? new DHSessionKeyBuilder.PrecalcRunner(context) : null;
    108116        _xdhThread = enableNTCP2 ? new X25519KeyFactory(context) : null;
    109117    }
     
    150158     *  Hook for pluggable transport creation.
    151159     *
     160     *  @return null if both NTCP1 and SSU are disabled
    152161     *  @since 0.9.16
    153162     */
     
    173182
    174183    private void configTransports() {
    175         boolean enableUDP = _context.getBooleanPropertyDefaultTrue(PROP_ENABLE_UDP);
    176184        Transport udp = null;
    177         if (enableUDP) {
     185        if (_enableUDP) {
    178186            udp = new UDPTransport(_context, _dhThread);
    179187            addTransport(udp);
     
    181189        }
    182190        if (isNTCPEnabled(_context)) {
    183             Transport ntcp = new NTCPTransport(_context, _dhThread, _xdhThread);
     191            DHSessionKeyBuilder.PrecalcRunner dh = _enableNTCP1 ? _dhThread : null;
     192            Transport ntcp = new NTCPTransport(_context, dh, _xdhThread);
    184193            addTransport(ntcp);
    185194            initializeAddress(ntcp);
     
    316325
    317326    synchronized void startListening() {
    318         if (_dhThread.getState() == Thread.State.NEW)
     327        if (_dhThread != null && _dhThread.getState() == Thread.State.NEW)
    319328            _dhThread.start();
    320329        if (_xdhThread != null && _xdhThread.getState() == Thread.State.NEW)
     
    378387    synchronized void shutdown() {
    379388        stopListening();
    380         _dhThread.shutdown();
     389        if (_dhThread != null)
     390            _dhThread.shutdown();
    381391        if (_xdhThread != null)
    382392            _xdhThread.shutdown();
  • router/java/src/net/i2p/router/transport/ntcp/EstablishBase.java

    rb310c60 r636016d1  
    192192        _transport = transport;
    193193        _con = con;
     194        // null if NTCP1 disabled
    194195        _dh = _transport.getDHBuilder();
    195196        _hX_xor_bobIdentHash = SimpleByteCache.acquire(HXY_SIZE);
    196197        if (_con.isInbound()) {
    197198            _X = SimpleByteCache.acquire(XY_SIZE);
    198             _Y = _dh.getMyPublicValueBytes();
     199            _Y = (_dh != null) ?_dh.getMyPublicValueBytes() : null;
    199200        } else {
     201            // OutboundNTCP2State does not extend this,
     202            // can't get here with NTCP1 disabled
     203            if (_dh == null)
     204                throw new IllegalStateException();
    200205            _X = _dh.getMyPublicValueBytes();
    201206            _Y = SimpleByteCache.acquire(XY_SIZE);
     
    305310        SimpleByteCache.release(_curDecrypted);
    306311        SimpleByteCache.release(_hX_xor_bobIdentHash);
    307         if (_dh.getPeerPublicValue() == null)
     312        if (_dh != null && _dh.getPeerPublicValue() == null)
    308313            _transport.returnUnused(_dh);
    309314    }
  • router/java/src/net/i2p/router/transport/ntcp/InboundEstablishState.java

    rb310c60 r636016d1  
    124124        if (!_transport.isNTCP2Enabled())
    125125            return 1;
     126        if (!_transport.isNTCP1Enabled())
     127            return 2;
    126128        synchronized (_stateLock) {
    127129            if (_state == State.IB_INIT)
     
    161163                    return;
    162164                }
    163                 if (remaining + _received < NTCP1_MSG1_SIZE) {
     165                if (remaining + _received < NTCP1_MSG1_SIZE ||
     166                    !_transport.isNTCP1Enabled()) {
    164167                    // Less than 288 total received, assume NTCP2
    165168                    // TODO can't change our mind later if we get more than 287
     
    744747                return;
    745748            }
     749            // TODO if NTCP1 disabled, we should allow longer padding
    746750            if (_padlen1 > PADDING1_MAX) {
    747751                fail("bad msg 1 padlen: " + _padlen1);
  • router/java/src/net/i2p/router/transport/ntcp/NTCPTransport.java

    rb310c60 r636016d1  
    138138    private static final int NTCP2_KEY_LEN = OutboundNTCP2State.KEY_SIZE;
    139139    private static final long MIN_DOWNTIME_TO_REKEY = 30*24*60*60*1000L;
     140    private final boolean _enableNTCP1;
    140141    private final boolean _enableNTCP2;
    141142    private final byte[] _ntcp2StaticPubkey;
     
    146147
    147148    /**
     149     *  @param dh null to disable NTCP1
    148150     *  @param xdh null to disable NTCP2
    149151     */
     
    239241        _transientFail = new SharedBid(TransportBid.TRANSIENT_FAIL);
    240242
     243        _enableNTCP1 = dh != null;
    241244        _enableNTCP2 = xdh != null;
     245        if (!_enableNTCP1 && !_enableNTCP2)
     246            throw new IllegalArgumentException();
    242247        if (_enableNTCP2) {
    243248            boolean shouldSave = false;
     
    578583        for (int i = 0; i < addrs.size(); i++) {
    579584            RouterAddress addr = addrs.get(i);
     585            // use this to skip outbound-only NTCP2,
     586            // and NTCP1 if disabled
     587            if (getNTCPVersion(addr) == 0)
     588                continue;
    580589            byte[] ip = addr.getIP();
    581590            if (!TransportUtil.isValidPort(addr.getPort()) || ip == null) {
     
    841850                    addNTCP2Options(props);
    842851                    int cost = getDefaultCost(ia instanceof Inet6Address);
    843                     myAddress = new RouterAddress(STYLE, props, cost);
     852                    myAddress = new RouterAddress(getPublishStyle(), props, cost);
    844853                    replaceAddress(myAddress);
    845854                }
     
    970979                    addNTCP2Options(props);
    971980                    int cost = getDefaultCost(false);
    972                     myAddress = new RouterAddress(STYLE, props, cost);
     981                    myAddress = new RouterAddress(getPublishStyle(), props, cost);
    973982                }
    974983                if (!_endpoints.isEmpty()) {
     
    10531062    net.i2p.router.transport.ntcp.Writer getWriter() { return _writer; }
    10541063
     1064    /**
     1065     * @return always "NTCP" even if NTCP1 is disabled
     1066     */
    10551067    public String getStyle() { return STYLE; }
    10561068
     
    10661078
    10671079    /**
     1080     * @return "NTCP" if NTCP1 is enabled, else "NTCP2"
     1081     * @since 0.9.39
     1082     */
     1083    private String getPublishStyle() {
     1084        return _enableNTCP1 ? STYLE : STYLE2;
     1085    }
     1086
     1087    /**
    10681088     *  Hook for NTCPConnection
    10691089     */
     
    10711091
    10721092    /**
     1093     *  @return null if not configured for NTCP1
    10731094     *  @since 0.9
    10741095     */
    10751096    DHSessionKeyBuilder getDHBuilder() {
    1076         return _dhFactory.getBuilder();
     1097        return _dhFactory != null ? _dhFactory.getBuilder() : null;
    10771098    }
    10781099
     
    10931114     */
    10941115    void returnUnused(DHSessionKeyBuilder builder) {
    1095         _dhFactory.returnUnused(builder);
     1116        if (_dhFactory != null)
     1117            _dhFactory.returnUnused(builder);
    10961118    }
    10971119
     
    11861208        addNTCP2Options(props);
    11871209        int cost = getDefaultCost(false);
    1188         RouterAddress addr = new RouterAddress(STYLE, props, cost);
     1210        RouterAddress addr = new RouterAddress(getPublishStyle(), props, cost);
    11891211        return addr;
    11901212    }
     
    12051227        props.setProperty("v", NTCP2_VERSION);
    12061228    }
     1229
     1230    /**
     1231     * Is NTCP1 enabled?
     1232     *
     1233     * @since 0.9.39
     1234     */
     1235    boolean isNTCP1Enabled() { return _enableNTCP1; }
    12071236
    12081237    /**
     
    12681297            addr.getOption("s") == null ||
    12691298            (!v.equals(NTCP2_VERSION) && !v.startsWith(NTCP2_VERSION_ALT))) {
    1270             return (rv == 1) ? 1 : 0;
    1271         }
    1272         // todo validate s/i b64, or just catch it later?
     1299            // his address is NTCP1 or is outbound NTCP2 only
     1300            return (rv == 1 && _enableNTCP1) ? 1 : 0;
     1301        }
     1302        // his address is NTCP2
     1303        // do not validate the s/i b64, we will just catch it later
    12731304        return NTCP2_INT_VERSION;
    12741305    }
     
    14621493            newProps.putAll(oldAddr.getOptionsMap());
    14631494        }
    1464         RouterAddress newAddr = new RouterAddress(STYLE, newProps, cost);
     1495        RouterAddress newAddr = new RouterAddress(getPublishStyle(), newProps, cost);
    14651496
    14661497        boolean changed = false;
     
    15331564            if (ohost == null || ! ohost.equalsIgnoreCase(nhost)) {
    15341565                newProps.setProperty(RouterAddress.PROP_HOST, nhost);
     1566                if (cost == NTCP2_OUTBOUND_COST)
     1567                    newAddr.setCost(DEFAULT_COST);
    15351568                changed = true;
    15361569            }
     
    15441577                _log.info("old host: " + ohost + " config: " + name + " new: " + name);
    15451578            newProps.setProperty(RouterAddress.PROP_HOST, name);
     1579            if (cost == NTCP2_OUTBOUND_COST)
     1580                newAddr.setCost(DEFAULT_COST);
    15461581            changed = true;
    15471582        } else if (ohost == null || ohost.length() <= 0) {
Note: See TracChangeset for help on using the changeset viewer.