Changeset 25bce10


Ignore:
Timestamp:
Apr 19, 2016 12:11:46 AM (4 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
e9cf4c2
Parents:
909622f
Message:

Addressbook: Add sign/verify methods for inner signature
Add preliminary handling of incoming actions

Location:
apps/addressbook/java/src/net/i2p/addressbook
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • apps/addressbook/java/src/net/i2p/addressbook/Daemon.java

    r909622f r25bce10  
    137137            // yes, the EepGet fetch() is done in next()
    138138            long start = System.currentTimeMillis();
    139             AddressBook sub = iter.next();
     139            AddressBook addressbook = iter.next();
    140140            // SubscriptionIterator puts in a dummy AddressBook with no location if no fetch is done
    141             if (DEBUG && log != null && sub.getLocation() != null) {
     141            if (DEBUG && log != null && addressbook.getLocation() != null) {
    142142                long end = System.currentTimeMillis();
    143                 log.append("Fetch of " + sub.getLocation() + " took " + (end - start));
     143                log.append("Fetch of " + addressbook.getLocation() + " took " + (end - start));
    144144                start = end;
    145145            }
    146146            int old = 0, nnew = 0, invalid = 0, conflict = 0, total = 0;
    147             for (Iterator<Map.Entry<String, HostTxtEntry>> eIter = sub.iterator(); eIter.hasNext(); ) {
    148                 Map.Entry<String, HostTxtEntry> entry = eIter.next();
     147            int deleted = 0;
     148            for (Map.Entry<String, HostTxtEntry> entry : addressbook) {
     149                total++;
    149150                String key = entry.getKey();
    150151                boolean isKnown;
    151                 Destination oldDest = null;
     152                // NOT set for text file NamingService
     153                Destination oldDest;
    152154                if (isTextFile) {
    153155                    if (knownNames == null) {
     
    157159                        knownNames = router.getNames(opts);
    158160                    }
     161                    oldDest = null;
    159162                    isKnown = knownNames.contains(key);
    160163                } else {
     
    163166                }
    164167                try {
    165                     if (!isKnown) {
     168                    HostTxtEntry he = entry.getValue();
     169                    Properties hprops = he.getProps();
     170                    boolean mustValidate = MUST_VALIDATE || hprops != null;
     171                    String action = hprops != null ? hprops.getProperty(HostTxtEntry.PROP_ACTION) : null;
     172                    if (mustValidate && !he.hasValidSig()) {
     173                        if (log != null) {
     174                            if (isKnown)
     175                                log.append("Bad signature for old key " + key);
     176                            else
     177                                log.append("Bad signature for new key " + key);
     178                        }
     179                        invalid++;
     180                    } else if (action != null || !isKnown) {
    166181                        if (AddressBook.isValidKey(key)) {
    167                             HostTxtEntry he = entry.getValue();
    168182                            Destination dest = new Destination(he.getDest());
    169183                            Properties props = new OrderedProperties();
    170                             props.setProperty("s", sub.getLocation());
    171                             if (he.hasValidSig()) {
     184                            props.setProperty("s", addressbook.getLocation());
     185                            if (mustValidate) {
     186                                // sig checked above
    172187                                props.setProperty("v", "true");
    173                             } else if (MUST_VALIDATE) {
    174                                 // TODO
    175                                 //if (log != null)
    176                                 //    log.append("Bad signature for new key " + key);
    177                                 continue;
    178188                            }
    179                             Properties hprops = he.getProps();
    180189                            if (hprops != null) {
    181190                                // merge in all the received properties
     
    185194                                }
    186195                            }
     196                            if (action != null) {
     197                                // Process commands. hprops is non-null.
     198                                // Must handle isKnown in each case.
     199                                if (action.equals(HostTxtEntry.ACTION_ADDDEST)) {
     200                                    // Add an alternate destination (new crypto) for existing hostname
     201                                    // Requires new NamingService support if the key exists
     202                                    String polddest = hprops.getProperty(HostTxtEntry.PROP_OLDDEST);
     203                                    if (polddest != null) {
     204                                        Destination pod = new Destination(polddest);
     205                                        // fill in oldDest for .txt naming service
     206                                        if (isKnown && isTextFile)
     207                                            oldDest = router.lookup(key);
     208                                        if (pod.equals(dest)) {
     209                                            // invalid
     210                                            if (log != null)
     211                                                log.append("Action: " + action + " failed because" +
     212                                                           " identical old and new destinations for " + key +
     213                                                           " from " + addressbook.getLocation());
     214                                            invalid++;
     215                                            continue;
     216                                        } else if (!isKnown) {
     217                                            // we didn't know it before, so we'll add it
     218                                        } else if (dest.equals(oldDest)) {
     219                                            // we knew it before, with the same dest
     220                                            old++;
     221                                            continue;
     222                                        } else if (pod.equals(oldDest)) {
     223                                            // checks out, so verify the inner sig
     224                                            if (!he.hasValidInnerSig()) {
     225                                                if (log != null)
     226                                                    log.append("Action: " + action + " failed because" +
     227                                                               " inner signature for key " + key +
     228                                                               " failed" +
     229                                                               " from " + addressbook.getLocation());
     230                                                invalid++;
     231                                                continue;
     232                                            }
     233                                            // TODO Requires NamingService support
     234                                            // if (isTextFile), do we replace or not? check sigType.isAvailable()
     235                                            // router.addAltDest(dest)
     236                                            if (log != null)
     237                                                log.append("Action: " + action + " unimplemented" +
     238                                                           " from " + addressbook.getLocation());
     239                                            invalid++;
     240                                            continue;
     241                                        }
     242                                    } else {
     243                                        if (log != null)
     244                                            log.append("Action: " + action + " failed, missing required parameters");
     245                                        invalid++;
     246                                        continue;
     247                                    }
     248                                } else if (action.equals(HostTxtEntry.ACTION_ADDNAME)) {
     249                                    // Add an alias for an existing hostname, same dest
     250                                    if (isKnown) {
     251                                        // could be same or different dest
     252                                        old++;
     253                                        continue;
     254                                    }
     255                                    String poldname = hprops.getProperty(HostTxtEntry.PROP_OLDNAME);
     256                                    if (poldname != null) {
     257                                        Destination pod = router.lookup(poldname);
     258                                        if (pod == null) {
     259                                            // we didn't have the old one, so we'll add the new one
     260                                        } else if (pod.equals(dest)) {
     261                                            // checks out, so we'll add the new one
     262                                        } else {
     263                                            // mismatch, disallow
     264                                            if (log != null)
     265                                                log.append("Action: " + action + " failed because" +
     266                                                           " destination for old name " + poldname +
     267                                                           " does not match" +
     268                                                           " from " + addressbook.getLocation());
     269                                            invalid++;
     270                                            continue;
     271                                        }
     272                                    } else {
     273                                        if (log != null)
     274                                            log.append("Action: " + action + " failed, missing required parameters" +
     275                                                       " from " + addressbook.getLocation());
     276                                        invalid++;
     277                                        continue;
     278                                    }
     279                                } else if (action.equals(HostTxtEntry.ACTION_ADDSUBDOMAIN)) {
     280                                    // add a subdomain with verification
     281                                    if (isKnown) {
     282                                        old++;
     283                                        continue;
     284                                    }
     285                                    String polddest = hprops.getProperty(HostTxtEntry.PROP_OLDDEST);
     286                                    String poldname = hprops.getProperty(HostTxtEntry.PROP_OLDNAME);
     287                                    if (polddest != null && poldname != null) {
     288                                        // check for valid subdomain
     289                                        if (!AddressBook.isValidKey(poldname) ||
     290                                            key.indexOf('.' + poldname) <= 0) {
     291                                            if (log != null)
     292                                                log.append("Action: " + action + " failed because" +
     293                                                           " old name " + poldname +
     294                                                           " is invalid" +
     295                                                           " from " + addressbook.getLocation());
     296                                            invalid++;
     297                                            continue;
     298                                        }
     299                                        Destination pod = new Destination(polddest);
     300                                        Destination pod2 = router.lookup(poldname);
     301                                        if (pod2 == null) {
     302                                            // we didn't have the old name
     303                                        } else if (pod.equals(pod2)) {
     304                                            // checks out, so verify the inner sig
     305                                            if (!he.hasValidInnerSig()) {
     306                                                if (log != null)
     307                                                    log.append("Action: " + action + " failed because" +
     308                                                               " inner signature for old name " + poldname +
     309                                                               " failed" +
     310                                                               " from " + addressbook.getLocation());
     311                                                invalid++;
     312                                                continue;
     313                                            }
     314                                        } else {
     315                                            // mismatch, disallow
     316                                            if (log != null)
     317                                                log.append("Action: " + action + " failed because" +
     318                                                           " destination for old name " + poldname +
     319                                                           " does not match provided" +
     320                                                           " from " + addressbook.getLocation());
     321                                            invalid++;
     322                                            continue;
     323                                        }
     324                                    } else {
     325                                        if (log != null)
     326                                            log.append("Action: " + action + " failed, missing required parameters" +
     327                                                       " from " + addressbook.getLocation());
     328                                        invalid++;
     329                                        continue;
     330                                    }
     331                                } else if (action.equals(HostTxtEntry.ACTION_CHANGEDEST)) {
     332                                    // change destination on an existing entry
     333                                    String polddest = hprops.getProperty(HostTxtEntry.PROP_OLDDEST);
     334                                    if (polddest != null) {
     335                                        Destination pod = new Destination(polddest);
     336                                        // fill in oldDest for .txt naming service
     337                                        if (isKnown && isTextFile)
     338                                            oldDest = router.lookup(key);
     339                                        if (!isKnown) {
     340                                            // we didn't have the old name
     341                                        } else if (pod.equals(oldDest)) {
     342                                            // checks out, so verify the inner sig
     343                                            if (!he.hasValidInnerSig()) {
     344                                                if (log != null)
     345                                                    log.append("Action: " + action + " failed because" +
     346                                                               " inner signature for key " + key +
     347                                                               " failed" +
     348                                                               " from " + addressbook.getLocation());
     349                                                invalid++;
     350                                                continue;
     351                                            }
     352                                            // TODO set flag to do non-putifabsent for published below
     353                                        } else {
     354                                            // mismatch, disallow
     355                                            if (log != null)
     356                                                log.append("Action: " + action + " failed because" +
     357                                                           " destination for key " + key +
     358                                                           " does not match provided" +
     359                                                           " from " + addressbook.getLocation());
     360                                            invalid++;
     361                                            continue;
     362                                        }
     363                                    } else {
     364                                        if (log != null)
     365                                            log.append("Action: " + action + " failed, missing required parameters" +
     366                                                       " from " + addressbook.getLocation());
     367                                        invalid++;
     368                                        continue;
     369                                    }
     370                                } else if (action.equals(HostTxtEntry.ACTION_CHANGENAME)) {
     371                                    // Delete old name, replace with new
     372                                    if (isKnown) {
     373                                        old++;
     374                                        continue;
     375                                    }
     376                                    String poldname = hprops.getProperty(HostTxtEntry.PROP_OLDNAME);
     377                                    if (poldname != null) {
     378                                        Destination pod = router.lookup(poldname);
     379                                        if (pod == null) {
     380                                            // we didn't have the old name
     381                                        } else if (pod.equals(dest)) {
     382                                            // checks out, so we'll delete it
     383                                            if (knownNames != null)
     384                                                knownNames.remove(poldname);
     385                                            boolean success = router.remove(poldname);
     386                                            if (success)
     387                                                deleted++;
     388                                            if (log != null) {
     389                                                if (success)
     390                                                    log.append("Removed: " + poldname +
     391                                                               " to be replaced with " + key +
     392                                                               " from " + addressbook.getLocation());
     393                                                else
     394                                                    log.append("Remove failed for: " + poldname +
     395                                                               " to be replaced with " + key +
     396                                                               " from " + addressbook.getLocation());
     397                                            }
     398                                            // now update the published addressbook
     399                                            if (published != null) {
     400                                                if (publishedNS == null)
     401                                                    publishedNS = new SingleFileNamingService(I2PAppContext.getGlobalContext(), published.getAbsolutePath());
     402                                                success = publishedNS.remove(poldname);
     403                                                if (log != null && !success)
     404                                                    log.append("Remove from published address book " + published.getAbsolutePath() + " failed for " + poldname);
     405                                            }
     406                                        } else {
     407                                            // mismatch, disallow
     408                                            if (log != null)
     409                                                log.append("Action: " + action + " failed because" +
     410                                                           " destination for old name " + poldname +
     411                                                           " does not match new name " + key +
     412                                                           " from " + addressbook.getLocation());
     413                                            invalid++;
     414                                            continue;
     415                                        }
     416                                    } else {
     417                                        if (log != null)
     418                                            log.append("Action: " + action + " failed, missing required parameters" +
     419                                                       " from " + addressbook.getLocation());
     420                                        invalid++;
     421                                        continue;
     422                                    }
     423                                } else if (action.equals(HostTxtEntry.ACTION_REMOVE)) {
     424                                    // FIXME can't get here, no key or dest
     425                                    // delete this entry
     426                                    if (!isKnown) {
     427                                        old++;
     428                                        continue;
     429                                    }
     430                                    String polddest = hprops.getProperty(HostTxtEntry.PROP_DEST);
     431                                    String poldname = hprops.getProperty(HostTxtEntry.PROP_NAME);
     432                                    if (polddest != null && poldname != null) {
     433                                        Destination pod = new Destination(polddest);
     434                                        Destination pod2 = router.lookup(poldname);
     435                                        if (pod.equals(pod2)) {
     436                                            if (knownNames != null)
     437                                                knownNames.remove(poldname);
     438                                            boolean success = router.remove(poldname);
     439                                            if (success)
     440                                                deleted++;
     441                                            if (log != null) {
     442                                                if (success)
     443                                                    log.append("Removed: " + poldname +
     444                                                               " as requested" +
     445                                                               " from " + addressbook.getLocation());
     446                                                else
     447                                                    log.append("Remove failed for: " + poldname +
     448                                                               " as requested" +
     449                                                               " from " + addressbook.getLocation());
     450                                            }
     451                                            // now update the published addressbook
     452                                            if (published != null) {
     453                                                if (publishedNS == null)
     454                                                    publishedNS = new SingleFileNamingService(I2PAppContext.getGlobalContext(), published.getAbsolutePath());
     455                                                success = publishedNS.remove(poldname);
     456                                                if (log != null && !success)
     457                                                    log.append("Remove from published address book " + published.getAbsolutePath() + " failed for " + poldname);
     458                                            }
     459                                        } else if (pod2 != null) {
     460                                            // mismatch, disallow
     461                                            if (log != null)
     462                                                log.append("Action: " + action + " failed because" +
     463                                                           " destination for " + poldname +
     464                                                           " does not match" +
     465                                                           " from " + addressbook.getLocation());
     466                                            invalid++;
     467                                        }
     468                                    } else {
     469                                        if (log != null)
     470                                            log.append("Action: " + action + " failed, missing required parameters" +
     471                                                       " from " + addressbook.getLocation());
     472                                        invalid++;
     473                                    }
     474                                    continue;
     475                                } else if (action.equals(HostTxtEntry.ACTION_REMOVEALL)) {
     476                                    // FIXME can't get here, no key or dest
     477                                    // delete all entries with this destination
     478                                    if (!isKnown) {
     479                                        old++;
     480                                        continue;
     481                                    }
     482                                    String polddest = hprops.getProperty(HostTxtEntry.PROP_DEST);
     483                                    // oldname is optional, but nice because not all books support reverse lookup
     484                                    if (polddest != null) {
     485                                        Destination pod = new Destination(polddest);
     486                                        String poldname = hprops.getProperty(HostTxtEntry.PROP_NAME);
     487                                        if (poldname != null) {
     488                                            Destination pod2 = router.lookup(poldname);
     489                                            if (pod.equals(pod2)) {
     490                                                if (knownNames != null)
     491                                                    knownNames.remove(poldname);
     492                                                boolean success = router.remove(poldname);
     493                                                if (success)
     494                                                    deleted++;
     495                                                if (log != null) {
     496                                                    if (success)
     497                                                        log.append("Removed: " + poldname +
     498                                                                   " as requested" +
     499                                                                   " from " + addressbook.getLocation());
     500                                                    else
     501                                                        log.append("Remove failed for: " + poldname +
     502                                                                   " as requested" +
     503                                                                   " from " + addressbook.getLocation());
     504                                                }
     505                                                // now update the published addressbook
     506                                                if (published != null) {
     507                                                    if (publishedNS == null)
     508                                                        publishedNS = new SingleFileNamingService(I2PAppContext.getGlobalContext(), published.getAbsolutePath());
     509                                                    success = publishedNS.remove(poldname);
     510                                                    if (log != null && !success)
     511                                                        log.append("Remove from published address book " + published.getAbsolutePath() + " failed for " + poldname);
     512                                                }
     513                                            } else if (pod2 != null) {
     514                                                // mismatch, disallow
     515                                                if (log != null)
     516                                                    log.append("Action: " + action + " failed because" +
     517                                                               " destination for " + poldname +
     518                                                               " does not match" +
     519                                                               " from " + addressbook.getLocation());
     520                                                invalid++;
     521                                            }
     522                                        }
     523                                        // reverse lookup, delete all
     524                                        // There's no NamingService API to get a list of all reverse
     525                                        String rev;
     526                                        String rev2 = null;
     527                                        while ((rev = router.reverseLookup(pod)) != null) {
     528                                            // prevent getting stuck from buggy NS
     529                                            if (rev.equals(rev2))
     530                                                break;
     531                                            rev2 = rev;
     532                                            // forward check in case hash collision or something
     533                                            Destination fwd = router.lookup(rev);
     534                                            if (!pod.equals(fwd))
     535                                                break;  // can't go around again, fail
     536                                            if (knownNames != null)
     537                                                knownNames.remove(rev);
     538                                            boolean success = router.remove(rev);
     539                                            if (success)
     540                                                deleted++;
     541                                            if (log != null) {
     542                                                if (success)
     543                                                    log.append("Removed: " + rev +
     544                                                               " as requested" +
     545                                                               " from " + addressbook.getLocation());
     546                                                else
     547                                                    log.append("Remove failed for: " + rev +
     548                                                               " as requested" +
     549                                                               " from " + addressbook.getLocation());
     550                                            }
     551                                            // now update the published addressbook
     552                                            if (published != null) {
     553                                                if (publishedNS == null)
     554                                                    publishedNS = new SingleFileNamingService(I2PAppContext.getGlobalContext(), published.getAbsolutePath());
     555                                                success = publishedNS.remove(rev);
     556                                                if (log != null && !success)
     557                                                    log.append("Remove from published address book " + published.getAbsolutePath() + " failed for " + rev);
     558                                            }
     559                                        }
     560                                    } else {
     561                                        if (log != null)
     562                                            log.append("Action: " + action + " failed, missing required parameters" +
     563                                                       " from " + addressbook.getLocation());
     564                                        invalid++;
     565                                    }
     566                                    continue;
     567                                } else if (action.equals(HostTxtEntry.ACTION_UPDATE)) {
     568                                    if (isKnown) {
     569                                        // TODO set flag to do non-putifabsent for published below
     570                                    }
     571                                } else {
     572                                    if (log != null)
     573                                        log.append("Action: " + action + " unrecognized" +
     574                                                   " from " + addressbook.getLocation());
     575                                    invalid++;
     576                                    continue;
     577                                }
     578                            }
    187579                            boolean success = router.put(key, dest, props);
    188580                            if (log != null) {
    189581                                if (success)
    190582                                    log.append("New address " + key +
    191                                                " added to address book. From: " + sub.getLocation());
     583                                               " added to address book. From: " + addressbook.getLocation());
    192584                                else
    193585                                    log.append("Save to naming service " + router + " failed for new key " + key);
     
    199591                                success = publishedNS.putIfAbsent(key, dest, props);
    200592                                if (log != null && !success) {
    201                                     try {
    202                                         log.append("Save to published address book " + published.getCanonicalPath() + " failed for new key " + key);
    203                                     } catch (IOException ioe) {}
     593                                    log.append("Save to published address book " + published.getAbsolutePath() + " failed for new key " + key);
    204594                                }
    205595                            }
     
    210600                        } else if (log != null) {
    211601                            log.append("Bad hostname " + key + " from "
    212                                    + sub.getLocation());
     602                                   + addressbook.getLocation());
    213603                            invalid++;
    214604                        }       
     605                  /****
    215606                    } else if (false && DEBUG && log != null) {
    216607                        // lookup the conflict if we haven't yet (O(n**2) for text file)
     
    219610                        if (oldDest != null && !oldDest.toBase64().equals(entry.getValue())) {
    220611                            log.append("Conflict for " + key + " from "
    221                                        + sub.getLocation()
     612                                       + addressbook.getLocation()
    222613                                       + ". Destination in remote address book is "
    223614                                       + entry.getValue());
     
    226617                            old++;
    227618                        }
     619                   ****/
    228620                    } else {
    229621                        old++;
     
    231623                } catch (DataFormatException dfe) {
    232624                    if (log != null)
    233                         log.append("Invalid b64 for " + key + " From: " + sub.getLocation());
     625                        log.append("Invalid b64 for " + key + " From: " + addressbook.getLocation());
    234626                    invalid++;
    235627                }
    236                 total++;
    237628            }
    238629            if (DEBUG && log != null && total > 0) {
    239                 log.append("Merge of " + sub.getLocation() + " into " + router +
     630                log.append("Merge of " + addressbook.getLocation() + " into " + router +
    240631                           " took " + (System.currentTimeMillis() - start) + " ms with " +
    241632                           total + " total, " +
    242633                           nnew + " new, " +
    243634                           old + " old, " +
     635                           deleted + " deleted, " +
    244636                           invalid + " invalid, " +
    245637                           conflict + " conflicts");
    246             }
    247             sub.delete();
    248         }
     638            }  // entries
     639            addressbook.delete();
     640        }  // subscriptions
    249641        subscriptions.write();
    250642    }
  • apps/addressbook/java/src/net/i2p/addressbook/HostTxtEntry.java

    r909622f r25bce10  
    139139    }
    140140
     141    /**
     142     * Verify with the dest public key using the "sig" property
     143     */
    141144    public boolean hasValidSig() {
    142145        if (props == null)
     
    196199    }
    197200
     201    /**
     202     * Verify with the "olddest" property's public key using the "oldsig" property
     203     */
     204    public boolean hasValidInnerSig() {
     205        if (props == null)
     206            return false;
     207        boolean rv = false;
     208        // don't cache result
     209        if (true) {
     210            StringBuilder buf = new StringBuilder(1024);
     211            String sig = null;
     212            String olddest = null;
     213            buf.append(name);
     214            buf.append(KV_SEPARATOR);
     215            buf.append(dest);
     216            boolean started = false;
     217            for (Map.Entry<Object, Object> e : props.entrySet()) {
     218                String k = (String) e.getKey();
     219                String v = (String) e.getValue();
     220                if (k.equals(PROP_SIG)) {
     221                    continue;
     222                }
     223                if (k.equals(PROP_OLDSIG)) {
     224                    if (sig != null)
     225                        return false;
     226                    sig = v;
     227                    // remove from the written data
     228                    continue;
     229                }
     230                if (k.equals(PROP_OLDDEST)) {
     231                    if (olddest != null)
     232                        return false;
     233                    olddest = v;
     234                }
     235                if (started) {
     236                    buf.append(PROP_SEPARATOR);
     237                } else {
     238                    started = true;
     239                    buf.append(PROPS_SEPARATOR);
     240                }
     241                buf.append(k);
     242                buf.append(KV_SEPARATOR);
     243                buf.append(v);
     244            }
     245            if (sig == null || olddest == null)
     246                return false;
     247            byte[] sdata = Base64.decode(sig);
     248            if (sdata == null)
     249                return false;
     250            Destination d;
     251            try {
     252                d = new Destination(olddest);
     253            } catch (DataFormatException dfe) {
     254                return false;
     255            }
     256            SigningPublicKey spk = d.getSigningPublicKey();
     257            SigType type = spk.getType();
     258            if (type == null)
     259                return false;
     260            Signature s;
     261            try {
     262                s = new Signature(type, sdata);
     263            } catch (IllegalArgumentException iae) {
     264                return false;
     265            }
     266            rv = DSAEngine.getInstance().verifySignature(s, DataHelper.getUTF8(buf.toString()), spk);
     267        }
     268        return rv;
     269    }
     270
    198271    @Override
    199272    public int hashCode() {
     
    214287    }
    215288
    216     /** for testing only */
     289    /**
     290     * Sign and set the "sig" property
     291     * for testing only
     292     */
    217293    private void sign(SigningPrivateKey spk) {
     294        signIt(spk, PROP_SIG);
     295    }
     296
     297    /**
     298     * Sign and set the "oldsig" property
     299     * for testing only
     300     */
     301    private void signInner(SigningPrivateKey spk) {
     302        signIt(spk, PROP_OLDSIG);
     303    }
     304
     305    /**
     306     * for testing only
     307     * @param sigprop The signature property to set
     308     */
     309    private void signIt(SigningPrivateKey spk, String sigprop) {
    218310        if (props == null)
    219311            throw new IllegalStateException();
    220         Destination d;
    221         try {
    222             d = new Destination(dest);
    223         } catch (DataFormatException dfe) {
    224             throw new IllegalStateException("bah", dfe);
    225         }
    226312        StringBuilder buf = new StringBuilder(1024);
    227313        buf.append(name);
     
    232318            String k = (String) e.getKey();
    233319            String v = (String) e.getValue();
    234             if (k.equals(PROP_SIG))
     320            if (k.equals(sigprop))
    235321                throw new IllegalStateException();
    236322            if (started) {
     
    247333        if (s == null)
    248334            throw new IllegalArgumentException("sig failed");
    249         props.setProperty(PROP_SIG, s.toBase64());
     335        props.setProperty(sigprop, s.toBase64());
    250336    }
    251337
    252338    public static void main(String[] args) throws Exception {
     339        // outer
    253340        File f = new File("tmp-eepPriv.dat");
     341        // inner
     342        File f2 = new File("tmp-eepPriv2.dat");
    254343        PrivateKeyFile pkf = new PrivateKeyFile(f);
     344        PrivateKeyFile pkf2 = new PrivateKeyFile(f2);
    255345        pkf.createIfAbsent(SigType.EdDSA_SHA512_Ed25519);
     346        pkf2.createIfAbsent(SigType.DSA_SHA1);
    256347        OrderedProperties props = new OrderedProperties();
    257348        props.setProperty("c", "ccccccccccc");
    258349        props.setProperty("a", "aaaa");
     350        props.setProperty(PROP_OLDDEST, pkf2.getDestination().toBase64());
    259351        HostTxtEntry he = new HostTxtEntry("foo.i2p", pkf.getDestination().toBase64(), props);
    260352        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
     
    263355        out.flush();
    264356        SigningPrivateKey priv = pkf.getSigningPrivKey();
     357        SigningPrivateKey priv2 = pkf2.getSigningPrivKey();
     358        he.signInner(priv2);
     359        out.write("After signing inner:\n");
     360        he.write(out);
    265361        he.sign(priv);
    266362        out.write("After signing:\n");
    267363        he.write(out);
    268364        out.flush();
     365        System.out.println("Orig has valid inner sig? " + he.hasValidInnerSig());
    269366        System.out.println("Orig has valid sig? " + he.hasValidSig());
    270367        // now create 2nd, read in
     
    276373        line = line.substring(line.indexOf(PROPS_SEPARATOR) + 2);
    277374        HostTxtEntry he2 = new HostTxtEntry("foo.i2p", pkf.getDestination().toBase64(), line);
     375        System.out.println("Dupl. has valid inner sig? " + he2.hasValidInnerSig());
    278376        System.out.println("Dupl. has valid sig? " + he2.hasValidSig());
    279377        f.delete();
     378        f2.delete();
    280379    }
    281380}
Note: See TracChangeset for help on using the changeset viewer.