Changeset 973aab8


Ignore:
Timestamp:
May 28, 2019 3:12:20 PM (10 months ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
a3fe746
Parents:
0c7c1945
Message:

Blinding:

  • Blinding only throws IAE
  • Remove context arg from encode()
  • Hook in new form args on /configkeyring
  • Show b33 on /configkeyring
  • Remove support for appended secret in b33
  • Persist cache immediately when storing secret or privkey
  • Fix i2ptunnel for std. ls2
  • Add auth/secret required flags to BlindData?

more to do

Files:
9 edited

Legend:

Unmodified
Added
Removed
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/web/IndexBean.java

    r0c7c1945 r973aab8  
    565565        if (d != null) {
    566566            int mode = _helper.getEncryptMode(tunnel);
    567             if (mode > 1) {
     567            if (mode > 1 && mode < 10) {
    568568                try {
    569569                    String secret = _helper.getBlindedPassword(tunnel);
     
    571571                                            (mode == 3 || mode == 5 || mode == 7 || mode == 9);
    572572                    boolean requireAuth = mode >= 4 && mode <= 9;
    573                     return Blinding.encode(_context, d.getSigningPublicKey(), requireSecret, requireAuth);
     573                    return Blinding.encode(d.getSigningPublicKey(), requireSecret, requireAuth);
    574574                } catch (RuntimeException re) {}
    575575            }
  • apps/i2ptunnel/jsp/editServer.jsi

    r0c7c1945 r973aab8  
    463463                <option title="<%=intl._t("Only clients with the password will be able to connect")%>" value="3" <%=(curEncryptMode.equals("3") ? " selected=\"selected\"" : "")%> >
    464464                    <%=intl._t("Blinded with lookup password")%></option>
    465 <%
    466                          // TODO, unimplemented
    467 %>
    468465                <option title="<%=intl._t("Only clients with the encryption key will be able to connect")%>" value="4" <%=(curEncryptMode.equals("4") ? " selected=\"selected\"" : "")%> >
    469                     <%=intl._t("Blinded with shared key")%></option>
     466                    <%=intl._t("Blinded with shared key")%> (PSK)</option>
    470467                <option title="<%=intl._t("Only clients with the password and key will be able to connect")%>" value="5" <%=(curEncryptMode.equals("5") ? " selected=\"selected\"" : "")%> >
    471                     <%=intl._t("Blinded with lookup password and shared key")%></option>
     468                    <%=intl._t("Blinded with lookup password and shared key")%> (PSK)</option>
    472469                <option title="<%=intl._t("Only clients with the encryption key will be able to connect")%>" value="6" <%=(curEncryptMode.equals("6") ? " selected=\"selected\"" : "")%> >
    473470                    <%=intl._t("Blinded with per-user key")%> (PSK)</option>
  • apps/routerconsole/java/src/net/i2p/router/web/helpers/ConfigKeyringHandler.java

    r0c7c1945 r973aab8  
    11package net.i2p.router.web.helpers;
    22
     3import net.i2p.crypto.Blinding;
     4import net.i2p.crypto.EncType;
     5import net.i2p.crypto.SigType;
     6import net.i2p.data.Base64;
     7import net.i2p.data.BlindData;
    38import net.i2p.data.DataFormatException;
     9import net.i2p.data.Destination;
    410import net.i2p.data.Hash;
     11import net.i2p.data.PrivateKey;
    512import net.i2p.data.SessionKey;
     13import net.i2p.data.SigningPublicKey;
    614import net.i2p.router.web.FormHandler;
    715import net.i2p.util.ConvertToHash;
     
    1321    private String _peer;
    1422    private String _key;
     23    private String _secret;
     24    private int _mode;
    1525   
    1626    @Override
     
    1828        boolean adding = _action.equals(_t("Add key"));
    1929        if (adding || _action.equals(_t("Delete key"))) {
    20             if (_peer == null)
     30            if (_peer == null) {
    2131                addFormError(_t("You must enter a destination"));
    22             if (_key == null && adding)
    23                 addFormError(_t("You must enter a key"));
    24             if (_peer == null || (_key == null && adding))
    2532                return;
    26             Hash h = ConvertToHash.getHash(_peer);
     33            }
     34            Hash h = null;
     35            if (!_peer.endsWith(".b32.i2p") || _peer.length() <= 60) {
     36                // don't wait for several seconds for b33 lookup
     37                h = ConvertToHash.getHash(_peer);
     38            }
    2739            if (adding) {
    28                 SessionKey sk = new SessionKey();
    29                 try {
    30                     sk.fromBase64(_key);
    31                 } catch (DataFormatException dfe) {}
    32                 if (h == null || h.getData() == null) {
    33                     addFormError(_t("Invalid destination"));
    34                 } else if (_context.clientManager().isLocal(h)) {
    35                     // don't bother translating
    36                     addFormError("Cannot add key for local destination. Enable encryption in the Hidden Services Manager.");
    37                 } else if (sk.getData() == null) {
    38                     addFormError(_t("Invalid key"));
     40                byte[] b = null;
     41                if (_mode == 1 || _mode == 4 || _mode == 5) {
     42                    if (_key == null) {
     43                        addFormError(_t("You must enter a key"));
     44                        return;
     45                    }
     46                    b = Base64.decode(_key);
     47                    if (b == null || b.length != 32) {
     48                        addFormError(_t("Invalid key"));
     49                        return;
     50                    }
     51                }
     52                if (_mode == 1) {
     53                    // LS1
     54                    if (h == null || h.getData() == null) {
     55                        addFormError(_t("Invalid destination"));
     56                    } else if (_context.clientManager().isLocal(h)) {
     57                        // don't bother translating
     58                        addFormError("Cannot add key for local destination. Enable encryption in the Hidden Services Manager.");
     59                    } else {
     60                        SessionKey sk = new SessionKey(b);
     61                        _context.keyRing().put(h, sk);
     62                        addFormNotice(_t("Key for {0} added to keyring", h.toBase32()));
     63                    }
    3964                } else {
    40                     _context.keyRing().put(h, sk);
    41                     addFormNotice(_t("Key for {0} added to keyring", h.toBase32()));
     65                    if ((_mode == 3 || _mode == 5 || _mode == 7) && _secret == null) {
     66                        addFormError(_t("Lookup password required"));
     67                        return;
     68                    }
     69                    // b33 if supplied as hostname
     70                    BlindData bdin = null;
     71                    try {
     72                        bdin = Blinding.decode(_context, _peer);
     73                    } catch (IllegalArgumentException iae) {}
     74
     75                    // we need the dest or the spk, not just the desthash
     76                    SigningPublicKey spk = null;
     77                    Destination d = null;
     78                    // don't cause LS fetch
     79                    if (!_peer.endsWith(".b32.i2p"))
     80                        d = _context.namingService().lookup(_peer);
     81                    if (d != null) {
     82                        spk = d.getSigningPublicKey();
     83                    } else if (bdin != null) {
     84                        spk = bdin.getUnblindedPubKey();
     85                    }
     86                    if (spk == null) {
     87                        addFormError(_t("Requires hostname, destination, or blinded base32"));
     88                        return;
     89                    }
     90                    // from BlindCache
     91                    BlindData bdold = _context.netDb().getBlindData(spk);
     92                    if (bdold != null && d == null)
     93                        d = bdold.getDestination();
     94                    if (d != null && _context.clientManager().isLocal(d)) {
     95                        // don't bother translating
     96                        addFormError("Cannot add key for local destination. Enable encryption in the Hidden Services Manager.");
     97                        return;
     98                    }
     99
     100                    SigType blindType;
     101                    if (bdin != null) {
     102                        blindType = bdin.getBlindedSigType();
     103                    } else if (bdold != null) {
     104                        blindType = bdold.getBlindedSigType();
     105                    } else {
     106                        blindType = Blinding.getDefaultBlindedType(spk.getType());
     107                    }
     108
     109                    int atype;
     110                    PrivateKey pk;
     111                    if (_mode == 4 || _mode == 5) {
     112                        atype = BlindData.AUTH_PSK;
     113                        // use supplied pk
     114                        pk = new PrivateKey(EncType.ECIES_X25519, b);
     115                    } else if (_mode == 6 || _mode == 7) {
     116                        atype = BlindData.AUTH_DH;
     117                        // create new pk
     118                        b = new byte[32];
     119                        _context.random().nextBytes(b);
     120                        pk = new PrivateKey(EncType.ECIES_X25519, b);
     121                    } else {
     122                        // modes 2 and 3
     123                        atype = BlindData.AUTH_NONE;
     124                        pk = null;
     125                    }
     126                    if (_mode == 2 || _mode == 4 || _mode == 6)
     127                        _secret = null;
     128                    if (bdin != null) {
     129                        // more checks based on supplied b33
     130                        if (bdin.getSecretRequired() && _secret == null) {
     131                            addFormError(_t("Destination requires lookup password"));
     132                            return;
     133                        }
     134                        if (!bdin.getSecretRequired() && _secret != null) {
     135                            addFormError(_t("Destination does not require lookup password"));
     136                            return;
     137                        }
     138                        if (bdin.getAuthRequired() && pk == null) {
     139                            addFormError(_t("Destination requires encryption key"));
     140                            return;
     141                        }
     142                        if (!bdin.getAuthRequired() && pk != null) {
     143                            addFormError(_t("Destination does not require encryption key"));
     144                            return;
     145                        }
     146                    }
     147
     148                    // to BlindCache
     149                    BlindData bdout;
     150                    if (d != null) {
     151                        bdout = new BlindData(_context, d, blindType, _secret, atype, pk);
     152                    } else {
     153                        bdout = new BlindData(_context, spk, blindType, _secret, atype, pk);
     154                    }
     155                    if (bdold != null) {
     156                        // debug
     157                        addFormNotice("already cached: " + bdold);
     158                    }
     159                    try {
     160                        _context.netDb().setBlindData(bdout);
     161                        addFormNotice(_t("Key for {0} added to keyring", bdout.toBase32()));
     162                        if (_mode == 6 || _mode == 7) {
     163                            addFormNotice(_t("Send your new key to the server opererator") + ": " + pk.toPublic().toBase64());
     164                        }
     165                    } catch (IllegalArgumentException iae) {
     166                        addFormError(_t("Invalid destination") + ": " + iae.getMessage());
     167                    }
    42168                }
    43169            } else {  // Delete
     
    62188    public void setPeer(String peer) { if (peer != null) _peer = peer.trim(); }
    63189    public void setKey(String key) { if (key != null) _key = key.trim(); }
     190
     191    /** @since 0.9.41 */
     192    public void setNofilter_blindedPassword(String pw) {
     193         if (pw != null) {
     194             pw = pw.trim();
     195             if (pw.length() > 0)
     196                 _secret = pw;
     197        }
     198    }
     199
     200    /** @since 0.9.41 */
     201    public void setEncryptMode(String m) {
     202        try {
     203             _mode = Integer.parseInt(m);
     204        } catch (NumberFormatException nfe) {}
     205    }
    64206}
  • apps/routerconsole/java/src/net/i2p/router/web/helpers/ConfigKeyringHelper.java

    r0c7c1945 r973aab8  
    8686            // TODO sort by hostname
    8787            for (BlindData bd : bdata) {
     88                buf.append("\n<tr><td>");
     89                buf.append(bd.toBase32());
     90                buf.append("</td><td>");
    8891                Hash h = bd.getDestHash();
    89                 if (h == null)
    90                     continue;
    91                 buf.append("\n<tr><td>");
    92                 buf.append(h.toBase32());
    93                 buf.append("</td><td>");
    94                 String host = _context.namingService().reverseLookup(h);
    95                 if (host != null)
    96                     buf.append(host);
     92                if (h != null) {
     93                    String host = _context.namingService().reverseLookup(h);
     94                    if (host != null)
     95                        buf.append(host);
     96                }
    9797                buf.append("</td><td>");
    9898                int type = bd.getAuthType();
  • apps/routerconsole/jsp/configkeyring.jsp

    r0c7c1945 r973aab8  
    5353          <option title="<%=intl._t("Only clients with the password and key will be able to connect")%>" value="5">
    5454              <%=intl._t("Blinded with lookup password and shared key")%></option>
    55           <option title="<%=intl._t("Only clients with the encryption key will be able to connect")%>" value="8">
     55          <option title="<%=intl._t("Only clients with the encryption key will be able to connect")%>" value="6">
    5656              <%=intl._t("Blinded with per-user key")%> (DH)</option>
    57           <option title="<%=intl._t("Only clients with the password and key will be able to connect")%>" value="9">
     57          <option title="<%=intl._t("Only clients with the password and key will be able to connect")%>" value="7">
    5858              <%=intl._t("Blinded with lookup password and per-user key")%> (DH)</option>
    5959          </select></td>
  • core/java/src/net/i2p/crypto/Blinding.java

    r0c7c1945 r973aab8  
    5454     *  @param alpha must be SigType RedDSA_SHA512_Ed25519
    5555     *  @return SigType RedDSA_SHA512_Ed25519
    56      *  @throws UnsupportedOperationException unless supported SigTypes
    57      *  @throws IllegalArgumentException on bad inputs
     56     *  @throws IllegalArgumentException on bad inputs or unsupported SigTypes
    5857     */
    5958    public static SigningPublicKey blind(SigningPublicKey key, SigningPrivateKey alpha) {
     
    6160        if ((type != TYPE && type != TYPER) ||
    6261            alpha.getType() != TYPER)
    63             throw new UnsupportedOperationException();
     62            throw new IllegalArgumentException("Unsupported blinding from " + type + " to " + alpha.getType());
    6463        try {
    6564            EdDSAPublicKey jk = SigUtil.toJavaEdDSAKey(key);
     
    7877     *  @param alpha must be SigType RedDSA_SHA512_Ed25519
    7978     *  @return SigType RedDSA_SHA512_Ed25519
    80      *  @throws UnsupportedOperationException unless supported SigTypes
    81      *  @throws IllegalArgumentException on bad inputs
     79     *  @throws IllegalArgumentException on bad inputs or unsupported SigTypes
    8280     */
    8381    public static SigningPrivateKey blind(SigningPrivateKey key, SigningPrivateKey alpha) {
     
    8583        if ((type != TYPE && type != TYPER) ||
    8684            alpha.getType() != TYPER)
    87             throw new UnsupportedOperationException();
     85            throw new IllegalArgumentException("Unsupported blinding from " + type + " to " + alpha.getType());
    8886        try {
    8987            EdDSAPrivateKey jk = SigUtil.toJavaEdDSAKey(key);
     
    102100     *  @param alpha must be SigType RedDSA_SHA512_Ed25519
    103101     *  @return SigType EdDSA_SHA512_Ed25519
    104      *  @throws UnsupportedOperationException unless supported SigTypes
    105      *  @throws IllegalArgumentException on bad inputs
     102     *  @throws IllegalArgumentException on bad inputs or unsupported SigTypes
    106103     */
    107104    public static SigningPrivateKey unblind(SigningPrivateKey key, SigningPrivateKey alpha) {
    108105        if (key.getType() != TYPER || alpha.getType() != TYPER)
    109             throw new UnsupportedOperationException();
     106            throw new IllegalArgumentException("Unsupported blinding from " + key.getType() + " / " + alpha.getType());
    110107        try {
    111108            EdDSAPrivateKey bjk = SigUtil.toJavaEdDSAKey(key);
     
    125122     *  @param secret may be null or zero-length
    126123     *  @return SigType RedDSA_SHA512_Ed25519
    127      *  @throws UnsupportedOperationException unless supported SigTypes
    128      *  @throws IllegalArgumentException on bad inputs
     124     *  @throws IllegalArgumentException on bad inputs or unsupported SigTypes
    129125     *  @since 0.9.39
    130126     */
     
    142138     *  @param now for what time?
    143139     *  @return SigType RedDSA_SHA512_Ed25519
    144      *  @throws UnsupportedOperationException unless supported SigTypes
    145      *  @throws IllegalArgumentException on bad inputs
     140     *  @throws IllegalArgumentException on bad inputs or unsupported SigTypes
    146141     *  @since 0.9.39
    147142     */
    148143    public static SigningPrivateKey generateAlpha(I2PAppContext ctx, SigningPublicKey destspk,
    149144                                                  String secret, long now) {
     145        SigType type = destspk.getType();
     146        if (type != TYPE && type != TYPER)
     147            throw new IllegalArgumentException("Unsupported blinding from " + type);
    150148        String modVal;
    151149        synchronized(_fmt) {
     
    171169        System.arraycopy(INFO_ALPHA, 0, in, 0, INFO_ALPHA.length);
    172170        System.arraycopy(destspk.getData(), 0, in, INFO_ALPHA.length, destspk.length());
    173         DataHelper.toLong(in, stoff, 2, destspk.getType().getCode());
     171        DataHelper.toLong(in, stoff, 2, type.getCode());
    174172        DataHelper.toLong(in, stoff + 2, 2, TYPER.getCode());
    175173        Hash salt = ctx.sha().calculateHash(in);
     
    199197    /**
    200198     *  Decode a new-format b32 address.
    201      *  PRELIMINARY - Subject to change - see proposal 149
     199     *  See proposal 149.
    202200     *
    203201     *  @param address ending with ".b32.i2p"
    204      *  @throws IllegalArgumentException on bad inputs
    205      *  @throws UnsupportedOperationException unless supported SigTypes
    206      *  @since 0.9.40
    207      */
    208     public static BlindData decode(I2PAppContext ctx, String address) throws RuntimeException {
     202     *  @throws IllegalArgumentException on bad inputs or unsupported SigTypes
     203     *  @since 0.9.40
     204     */
     205    public static BlindData decode(I2PAppContext ctx, String address) throws IllegalArgumentException {
    209206        address = address.toLowerCase(Locale.US);
    210207        if (!address.endsWith(".b32.i2p"))
     
    220217    /**
    221218     *  Decode a new-format b32 address.
    222      *  PRELIMINARY - Subject to change - see proposal 149
     219     *  See proposal 149.
     220     *  NOTE: Not for external use, use decode(String)
    223221     *
    224222     *  @param b 35+ bytes
    225223     *  @return BlindData structure, use getUnblindedPubKey() for the result
    226      *  @throws IllegalArgumentException on bad inputs
    227      *  @throws UnsupportedOperationException unless supported SigTypes
    228      *  @since 0.9.40
    229      */
    230     public static BlindData decode(I2PAppContext ctx, byte[] b) throws RuntimeException {
     224     *  @throws IllegalArgumentException on bad inputs or unsupported SigTypes
     225     *  @since 0.9.40
     226     */
     227    public static BlindData decode(I2PAppContext ctx, byte[] b) throws IllegalArgumentException {
    231228        Checksum crc = new CRC32();
    232229        crc.update(b, 3, b.length - 3);
     
    240237        if ((flag & FLAG_TWOBYTE) != 0)
    241238            throw new IllegalArgumentException("Two byte sig types unsupported");
    242         if ((flag & FLAG_AUTH) != 0)
    243             throw new IllegalArgumentException("Per-client auth unsupported");
    244239        // TODO two-byte sigtypes
    245240        int st1 = b[1] & 0xff;
     
    262257        System.arraycopy(b, 3, spkData, 0, spkLen);
    263258        SigningPublicKey spk = new SigningPublicKey(sigt1, spkData);
    264         String secret;
    265         if ((flag & FLAG_SECRET) != 0) {
    266             if (4 + spkLen > b.length) {
    267                 //throw new IllegalArgumentException("No secret data");
    268                 secret = null;
    269             } else {
    270                 int secLen = b[3 + spkLen] & 0xff;
    271                 if (4 + spkLen + secLen != b.length)
    272                     throw new IllegalArgumentException("Bad b32 length");
    273                 secret = DataHelper.getUTF8(b, 4 + spkLen, secLen);
    274             }
    275         } else if (3 + spkLen != b.length) {
     259        if (3 + spkLen != b.length)
    276260            throw new IllegalArgumentException("b32 too long");
    277         } else {
    278             secret = null;
    279         }
    280         BlindData rv = new BlindData(ctx, spk, sigt2, secret);
     261        BlindData rv = new BlindData(ctx, spk, sigt2, null);
     262        if ((flag & FLAG_SECRET) != 0)
     263            rv.setSecretRequired();
     264        if ((flag & FLAG_AUTH) != 0)
     265            rv.setAuthRequired();
    281266        return rv;
    282267    }
     
    284269    /**
    285270     *  Encode a public key as a new-format b32 address.
    286      *  PRELIMINARY - Subject to change - see proposal 149
     271     *  See proposal 149.
    287272     *
    288273     *  @return (56 chars).b32.i2p
    289      *  @throws IllegalArgumentException on bad inputs
    290      *  @throws UnsupportedOperationException unless supported SigTypes
    291      *  @since 0.9.40
    292      */
    293     public static String encode(I2PAppContext ctx, SigningPublicKey key) throws RuntimeException {
    294         return encode(ctx, key, false, false, null);
     274     *  @throws IllegalArgumentException on bad inputs or unsupported SigTypes
     275     *  @since 0.9.40
     276     */
     277    public static String encode(SigningPublicKey key) throws IllegalArgumentException {
     278        return encode(key, false, false);
    295279    }
    296280
    297281    /**
    298282     *  Encode a public key as a new-format b32 address.
    299      *  PRELIMINARY - Subject to change - see proposal 149
     283     *  See proposal 149.
    300284     *
    301285     *  @return (56 chars).b32.i2p
    302      *  @throws IllegalArgumentException on bad inputs
    303      *  @throws UnsupportedOperationException unless supported SigTypes
    304      *  @since 0.9.40
    305      */
    306     public static String encode(I2PAppContext ctx, SigningPublicKey key,
    307                                 boolean requireSecret, boolean requireAuth) throws RuntimeException {
    308         return encode(ctx, key, requireSecret, requireAuth, null);
    309     }
    310 
    311     /**
    312      *  Encode a public key as a new-format b32 address.
    313      *  PRELIMINARY - Subject to change - see proposal 149
    314      *
    315      *  @param secret may be empty or null
    316      *  @return (56+ chars).b32.i2p
    317      *  @throws IllegalArgumentException on bad inputs
    318      *  @throws UnsupportedOperationException unless supported SigTypes
    319      *  @since 0.9.40
    320      */
    321     public static String encode(I2PAppContext ctx, SigningPublicKey key,
    322                                 boolean requireSecret, boolean requireAuth,
    323                                 String secret) throws RuntimeException {
     286     *  @throws IllegalArgumentException on bad inputs or unsupported SigTypes
     287     *  @since 0.9.40
     288     */
     289    public static String encode(SigningPublicKey key,
     290                                boolean requireSecret, boolean requireAuth) throws IllegalArgumentException {
    324291        SigType type = key.getType();
    325292        if (type != TYPE && type != TYPER)
    326             throw new UnsupportedOperationException();
    327         byte sdata[] = (secret != null) ? DataHelper.getUTF8(secret) : null;
    328         int slen = (secret != null) ? 1 + sdata.length : 0;
    329         if (slen > 256)
    330             throw new IllegalArgumentException("secret too long");
     293            throw new IllegalArgumentException("Unsupported blinding from " + type);
    331294        byte[] d = key.getData();
    332         byte[] b = new byte[d.length + slen + 3];
     295        byte[] b = new byte[d.length + 3];
    333296        System.arraycopy(d, 0, b, 3, d.length);
    334         if (slen > 0) {
    335             b[3 + d.length] = (byte) sdata.length;
    336             System.arraycopy(sdata, 0, b, 4 + d.length, sdata.length);
    337         }
    338297        Checksum crc = new CRC32();
    339298        crc.update(b, 3, b.length - 3);
    340299        long check = crc.getValue();
    341300        // TODO two-byte sigtypes
    342         if (slen > 0 || requireSecret)
     301        if (requireSecret)
    343302            b[0] = FLAG_SECRET;
    344303        if (requireAuth)
     
    368327        SigningPrivateKey priv = (SigningPrivateKey) keys[1];
    369328        I2PAppContext ctx = I2PAppContext.getGlobalContext();
    370         //String b32 = encode(ctx, pub, null);
    371         String b32 = encode(ctx, pub, "foobarbaz");
     329        //String b32 = encode(pub, null);
     330        String b32 = encode(pub, "foobarbaz");
    372331        System.out.println("pub b32 is " + b32);
    373332        BlindData bd = decode(ctx, b32);
  • core/java/src/net/i2p/data/BlindData.java

    r0c7c1945 r973aab8  
    2424    private Destination _dest;
    2525    private long _routingKeyGenMod;
     26    private boolean _secretRequired;
     27    private boolean _authRequired;
    2628
    2729    /**
     
    4042     */
    4143    public static final int AUTH_PSK = 3;
     44    /**
     45     * Enabled, unspecified type
     46     * @since 0.9.41
     47     */
     48    public static final int AUTH_ON = 999;
    4249
    4350    /**
     
    8491        _authType = authType;
    8592        _authKey = authKey;
     93        if (secret != null)
     94            _secretRequired = true;
     95        if (authKey != null)
     96            _authRequired = true;
    8697        // defer until needed
    8798        //calculate();
     
    197208        _blindHash = _context.sha().calculateHash(hashData);
    198209    }
    199    
     210
     211    /**
     212     *  b33 format
     213     *  @since 0.9.41
     214     */
     215    public synchronized String toBase32() {
     216        return Blinding.encode(_clearSPK, _secret != null, _authKey != null);
     217    }
     218
     219    /**
     220     *  @since 0.9.41
     221     */
     222    public void setSecretRequired() {
     223        _secretRequired = true;
     224    }
     225
     226    /**
     227     *  @since 0.9.41
     228     */
     229    public boolean getSecretRequired() {
     230        return _secretRequired;
     231    }
     232
     233    /**
     234     *  @since 0.9.41
     235     */
     236    public void setAuthRequired() {
     237        _authRequired = true;
     238    }
     239
     240    /**
     241     *  @since 0.9.41
     242     */
     243    public boolean getAuthRequired() {
     244        return _authRequired;
     245    }
     246
    200247    @Override
    201248    public synchronized String toString() {
     
    220267        else
    221268            buf.append("\n\tDestination: unknown");
     269        buf.append("\n\tB32             : ").append(toBase32());
    222270        buf.append(']');
    223271        return buf.toString();
  • core/java/src/net/i2p/data/PrivateKeyFile.java

    r0c7c1945 r973aab8  
    770770                type == SigType.RedDSA_SHA512_Ed25519) {
    771771                I2PAppContext ctx = I2PAppContext.getGlobalContext();
    772                 s.append("\nBlinded B32: ").append(Blinding.encode(ctx, spk));
     772                s.append("\nBlinded B32: ").append(Blinding.encode(spk));
    773773            }
    774774        }
  • router/java/src/net/i2p/router/networkdb/kademlia/BlindCache.java

    r0c7c1945 r973aab8  
    169169    }
    170170
     171    /**
     172     *  Persists immediately if secret or privkey is non-null
     173     */
    171174    public void addToCache(BlindData bd) {
     175        storeInCache(bd);
     176        if (bd.getSecret() != null || bd.getAuthPrivKey() != null)
     177            store();
     178    }
     179
     180    /**
     181     *  @since 0.9.41 from addToCache()
     182     */
     183    private void storeInCache(BlindData bd) {
    172184        _cache.put(bd.getUnblindedPubKey(), bd);
    173185        _reverseCache.put(bd.getBlindedPubKey(), bd);
     
    258270                    continue;
    259271                try {
    260                     addToCache(fromPersistentString(line));
     272                    storeInCache(fromPersistentString(line));
    261273                    count++;
    262274                } catch (IllegalArgumentException iae) {
Note: See TracChangeset for help on using the changeset viewer.