Esta página fue actualizada por última vez el 2021-12.

Introducción

Gracias por ofrecerse voluntario para ejecutar un servidor de resembrado de I2P. "Resembrar" es nuestro término para inicializar nuevos routers I2P en la red. Los nuevos routers I2P descargan un paquete de referencias de pares (peers), o informaciones del router ("router infos"), de una o más URLs HTTPS de una lista integrada.

Requerimientos

En su forma más simple, un servidor de resembrado consiste en un router I2P Java, un servidor web HTTPS, y algunos scripts que reunen periódicamente informaciones de routers desde el router I2P, las empaquetan y firman en un formato de fichero personalizado, y entregan estos ficheros sobre HTTPS. En la práctica, es un poco más complejo, y un operador de resembrado debe ser medianamente competente y despierto. Un servidor de resembrado no es apropiado para una conexión residencial a Internet. Las complejidades incluyen:

  • Debe tener una instalación SSL segura, bien con un certificado auto-firmado o bien con un certificado encadenado a una autoridad de certificación (CA) estándar
  • La configuración SSL debe adaptarse a las mejores prácticas actuales sobre códigos de cifrado y protocolos permitidos, y el nombre del servidor CN/SAN (nombre común y alternativos según el certificado SSL) debe coincidir con la URL
  • Los scripts están diseñados para entregar distintos datos de router I2P a diferentes peticionarios para mantener la diversidad de la red
  • Los scripts están diseñados para entregar el mismo paquete al mismo peticionario repetido para evitar dificultades
  • Los servidores de resembrado están bajo ataques e intentos de DDoS periódicos, y desde otras implementaciones I2P con fallos y redes de bots (botnets). Esto requiere que ejecute fail2ban o una solución equivalente.

Información requerida

Cuando su configuración esté completa y lista para la prueba, necesitaremos la URL HTTPS, el certificado de clave pública SSL (sólo si es autofirmado), y el certificado de clave pública su3. Una vez finalizadas las pruebas, se añadirán a las entradas codificadas en los routers Java y C++ en la próxima versión, y empezarás a ver el tráfico. También necesitaremos su dirección de correo electrónico para que podamos seguir poniéndonos en contacto con usted sobre cuestiones de administración de resiembra. La dirección de correo electrónico no se hará pública, pero será conocida por los demás operadores de reseed. Deberías esperar que tu nick o nombre y su asociación con esa URL o IP se hagan públicos.

Política de privacidad

Un operador de resembrado es una función de confianza en la red. Aunque aún no tenemos una política de privacidad formal, usted debe asegurar la privacidad de nuestros usuarios no haciendo públicos los registros (logs) o IPs que se encuentren en esos registros, exceptuando lo necesario para discutir problemas de administración con el equipo de resembrado de I2P.

Apoyo financiero

Un apoyo financiero modesto puede ponerse a disposición de aquellos que operen servidores de resembrado. Este apoyo sería un reembolso parcial de los costes de su servidor. Este apoyo no se pagará por adelantado y probablemente no cubrirá todos sus gastos. Sólo pueden acceder a este apoyo aquellos que han estado operando servidores de resembrado de forma estable durante varios meses, y está basado en necesidades reales.

Si desea solicitar ayuda, póngase en contacto con echelon y CC: zzz

Iniciarse

Nuestro coordinador de reseed es "zzz" y se puede contactar con él en zzz @ mail.i2p o zzz @ i2pmail.org. Por desgracia, no suele estar en IRC. La configuración de reseed es algo especializada, y deberías dirigirle la mayoría de las preguntas.

Para la actual implementación, vea los detalles debajo. Tenemos una solución de resembrado recomendada:

  • Una implementación Ir que incluye el servidor web y todos los scripts. esta es la solución recomendada.

Para más información, lea la información en los siguientes enlaces y, a continuación, póngase en contacto con zzz. Muchas gracias.

Instrucciones detalladas

How-to Public reseed servers - su3

  • Some parts of this how-to are copied from zzz.i2p and are modified.
  • Fetching individual RI (dat-files -the legacy/old style-) is not part of this how-to.
  • Questions can be placed on zzz.i2p - in the Reseeding sub-forum.

Table of contents

  1. Introduction
  2. Requirements
  3. Go Solution - Quick Guide
    1. Start Web Server
    2. Install git and golang
    3. Build and Test
    4. Run Reseed
    5. Backup Certificates and Keys
    6. Enable Autostart
    7. Connect Web Server to Reseed
    8. Test From Another Computer
    9. Send Us Your Certificates
  4. Go Solution -Detailed Guide
    1. Overview
    2. Building From Source
    3. Run The Reseed Server
    4. Draft For Startup Script
    5. Reverse-Proxy Setup
    6. Convert Existing Java Keystore to crt- and pem-file
  5. Seamless SSL-Certificate Exchange
  6. Reseed Server Domain/URL/Port Exchange
  7. Tests
  8. Contact Reseed Maintainer

1. Introduction

Public reseed servers are necessary to bootstrap into the I2P net. New installed I2P routers needs one-time about one hundred RouterInfo's (RI) as jump start.

RI contains IP and Port from other I2P routers and are stored in dat-files in the netDB folder.

A random bunch of dat-files from the netDB are zipped, then signed to a su3-file and finally offered to I2P routers seeking reseed service.

To secure bootstrap and enable a trusted start, HTTPS/TLS and signed su3-files are mandatory.

It is essential not to publish all RI from netDB, or all RI to one client.

2. Requirements

Requirements for running a public reseed server:

  • Well integrated running I2P router @ 24/7
  • Server with static IPv4 (2 cpu/ 2GB ram is fine)
  • Unix to run the golang solution
  • Own domain, sub-domain or an anonymous third-level domain
  • A self-signed SSL certificate, or an SSL certificate from Let's Encrypt
  • Enough bandwidth and traffic volume - Around 15 GB/month as of December 2016
  • Up-to-date web server (Apache/nginx), HTTPS ONLY with TLS 1.2 and good ciphers
Optional:
  • fail2ban to protect you from botnets
  • GnuPG/PGP for signed/encrypted emails
  • IPv6

This How-to is tested with Ubuntu/Debian as well as FreeBSD. The web server has to be public reachable from all over the world, an I2P Site inside I2P can be setup in addition. Also frequent or infrequent attempts to scrape all your reseed files, and of course attacks on your server. The web server doesn't need to listen at default SSL/TLS port 443 - any other port can be used for obfuscation.

3. Go Solution - Quick Guide

1. Fire Up Your Favorite Webserver

  1. Connect a domain, sub-domain or (anonymous) third-level-domain
  2. Setup a state-of-the-art TLS(SSL) certificate
  3. Allow access only via HTTPS/TLS, no unencrypted HTTP
  4. Allow only very good ciphers, compatible to Java 7/8/9. See Cipherli.st

Note: A non default port other than 443 can be used; TLS certificate can be self signed; configure fail2ban as bot-net protection

2. Install git and golang-go (1.4.2 or higher)

	Debian/Ubuntu:    sudo apt install git golang-go
        Arch:             sudo pacman -s git go

3. Switch To User Running I2P, Fetch the i2p-tool Source Code, Build and Test it

Note: Visit http://reseed.i2p and download a pre-build x86_64 binary, so you can skip step 2+3. 

	export GOPATH=$HOME/go; mkdir $GOPATH; cd $GOPATH
	go get github.com/martin61/i2p-tools
	bin/i2p-tools -h

4. Run i2p-tools locally,

Replace 'yourname@mail.i2p' with your email address Replace '/home/i/.i2p/netDb' with the path to the I2P 'netDb' in the home folder of the user running I2P 

	GOPATH=$HOME/go;
        cd $GOPATH;
        bin/i2p-tools reseed --signer=yourname@mail.i2p \
                             --netdb=/home/i/.i2p/netDb \
                             --port=8443 \
                             --ip=127.0.0.1 \
                             --trustProxy

5. Back Up New Certificates

Make a backup from the newly created su3-signing key and certificate found in $GOPATH (.crt/.pem/.crl) and keep it in a safe, password protected location

6. Enable Autostart (+restart) for i2p-tools in Your crontab

Replace '...' with the appropriate command-line arguments as in step 4 

	@reboot   GOPATH=$HOME/go; cd $GOPATH; bin/i2p-tools reseed ... >/dev/null 2>&1
	9 * * * * GOPATH=$HOME/go; cd $GOPATH; bin/i2p-tools reseed ... >/dev/null 2>&1

7. Connect Your Webserver via Reverse-Proxy setup to the i2p-tool, Examples

lighttpd is no longer supported due to a limitation with the 'X-Forwarded-For' HTTP Header. Please use Apache or nginx.

nginx configuration example: 

		location / {
			proxy_pass http://127.0.0.1:8443;
                        proxy_set_header X-Real-IP  $remote_addr;
                        proxy_set_header X-Forwarded-For $remote_addr;
		}

Apache (untested - feedback would be appreciated) 

		ProxyRequests Off
		<Proxy *>
			Order deny,allow
			Allow from all
		</Proxy>
		ProxyPass / http://127.0.0.1:8443/
		ProxyPassReverse / http://127.0.0.1:8443/

Additionally, ensure that your webserver uses these suggested settings for Strong SSL Security (visit CipherLi.st for the latest settings). Sample SSL settings are provided in section 4.5 Reverse-Proxy Setup.

Note: i2p-tool has also an build-in standalone webserver with TLS support which can be used without a webserver. Please contact (zzz at mail.i2p.de) if you need help, or stop by #i2p-dev on IRC2P and talk to other reseed operators.

8. Final Test From Another Computer With I2P Running

  1. Place your su3-certificate (*.crt) in i2p/certificates/reseed/
  2. Place your TLS-certificate (*.crt) in i2p/certificates/ssl/
  3. Visit with your web browser http://localhost:7657/configreseed
  4. Enter your new reseed-url and delete all others, hit "Save changes and reseed now"
  5. Check the I2P logs for "Reseed got 77 router infos from ... with 0 errors, Reseed complete, 77 received"

9. Send Us Your Information

  1. Domain/URL/Port
  2. su3-signing certificate
  3. TLS certificate (if self signed)

Send an email: zzz at mail.i2p, PGP signed welcome :-)

4. Go Solution - Detailed Instructions

1. Overview

The previous steps for reseeding involves many steps, scripts and programs. Most of them are easy and plain straight forward, but overall you can call it a little confusing.

Here comes now an all-in-one solution from matt (Big Thanks!) for providing a reseed server which merges the following functions into one binary:

  • Create su3-files
  • Create su3 signer certificate+key
  • Create SSL-certificate+key
  • Replaces the http-server and the PHP code (or run next to them in parallel)

Almost all previous used scripts and described steps are not needed with this solution, but to understand the overall reseed process it is recommended to read them too :-)

  • If you already have an SSL-certificate and su3-signer-key you can reuse them, see one of the following chapter.
  • For testing and new reseeders the required certs and keys are created automatically at first start.
  • Also take a look at the content and the naming scheme of these pem and crt files.

Of course you need an up-to-date netDB folder with routerinfos from a running I2P router. I2P does not have to be running on the same machine as this reseed binary. In this case you can setup a cronjob to transfer the netDB from the I2P machine to the reseed machine.

Matt's go solution can be used in parallel next to an already running http-server. For this leave the http-server running at normal port 80 and 443, and configure Go solution too use another port, e.g. port 8443.

More: at github, README.md, https://github.com/martin61/i2p-tools

2. Building From Source

Requirements:

  • go1.4.2 (older versions may not work)

Install go from https://golang.org/doc/install, example for 64 bit Ubuntu/Debian:

  • wget https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz
  • sudo tar -C /usr/local -xzf go1.4.2.linux-amd64.tar.gz
  • mkdir $HOME/go
  • edit /etc/profile and add: 
    	export GOPATH=$HOME/go
	export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin

Verify go: 

$ go version
which should state something like: "go version go1.4.2"

Install Go solution from https://github.com/martin61/i2p-tools into $HOME/go: 

$ go get github.com/martin61/i2p-tools

This will install a binary to $GOPATH/bin/i2p-tools

Run the go solution, the usage/help should be displayed, nothing more: 

$ i2p-tools

3. Run the Reseed Server

$ i2p-tools reseed --tlsHost=myserver.com --signer=myemail@mail.i2p --netdb=$HOME/.i2p/netDb
  • Replace myserver.com with your real domain
  • Replace myemail@mail.i2p with a valid existing email, which you want to use for reseeding purpose
  • New TLS certificate+key will be created (if they do not exist)
  • New signing certificate+key will be created (if they do not exist)
  • netdb=... should point to the netdb folder of your running I2P with the routerinfos
  • To use another port append "--port=443" to the command, default is port 8443

Output: 

2015/03/15 12:28:25 Rebuilding su3 cache...
2015/03/15 12:28:25 Building 200 su3 files each containing 75 out of 3180 routerInfos.
2015/03/15 12:28:35 Done rebuilding.
2015/03/15 12:28:35 HTTPS server started on 0.0.0.0:8443

So you can now test to reach the server at port 8443, see a previous chapter about proper testing.

Some remarks:

  • Don't run the server daemon as root
  • Every port between 1024 and 49151 is fine for I2P.
  • If you want to use the privileged (https-default) port 443, create a port redirect, e.g. 
    'iptables -A PREROUTING -t nat -p tcp --dport 443 -j REDIRECT --to-port 8443'
  • Redirect the output from the go solution to a logfile, format is default apache-style combined logs
  • Add a logrotate for the logfiles, since they grow big :-(
  • Logfiles can be used by fail2ban
  • Both of the certificates (*.crt) will need to be sent to the reseed maintainer in order for your reseed server to be included in the standard I2P package.
  • Add a proper startup script, to run the reseed server, see next chapter

4. Draft for Startup Script "seedserver"

The reseed server should be started automatically, so you need a init.d or some sort of startscript, here named as "seedserver". This is only a very first draft for a simple startscript (it could be done better :-))

Login as I2P user:

  • Place the shell-script "seedserver" in the /home/i2p/bin folder (next to i2p-tools)
  • Make it executable: chmod u+x /home/i2p/bin/seedserver
Update the header "# Your settings" with your individual settings.

Now you can use the shell-script: 

seedserver start

And then (give it some seconds) take a look at the status: 

seedserver status
seedserver showlog

Some short explanation about seedserver:

  • runs i2p-tools in the background
  • creates logfiles
  • take care of all settings

If this is working fine, you can put the script in your personal crontab, to run it by auto-start and to do logrotes simply by restarting it regularly once a week to avoid too big logfiles. If you already reboot your server regularly, you can skip of course the "restart" command line.

Login as I2P user, edit your crontab: 

crontab -e

and add these 3 lines at the end: 

@reboot /home/i2p/bin/seedserver startdelayed
04 14 * * 2 /home/i2p/bin/seedserver restart
#end

Save and close the editor. It would be good to check if this is properly working when you reboot your machine.

"seedserver" shell script: 

######################################################################################################
#!/bin/sh

# Your settings
toolpath=/home/i2p/bin
tlsHost=myserver.com
signer=myemail@mail.i2p
netdb="/home/i2p/.i2p/netDb"


tool=i2p-tools
logpath="$toolpath/${tool}.log"
logfile="$logpath/reseed.log"
errfile="$logpath/reseed.error"

cd "$toolpath"
mkdir --parents "$logpath"


do_status() {
/bin/sleep 1
if [ -n "$(pgrep -x "$tool")" ]; then
echo "$tool running, pid $(pgrep "$tool")"
else
echo "$tool not running."
fi;
}

do_start() {
if [ -z "$(pgrep -x "$tool")" ]; then
do_logrotate
nohup "$toolpath/$tool" reseed -tlsHost="$tlsHost" --signer="$signer" --netdb="$netdb" > "$logfile" 2> "$errfile" &
fi;
do_status
}

do_stop() {
if [ -n "$(pgrep -x "$tool")" ]; then
pkill "$tool"
fi;
do_status
}

do_startdelayed() {
echo "waiting 20s..."
/bin/sleep 20
do_start
}

do_restart() {
do_status
do_stop
do_start
}

do_logrotate() {
do_status
if [ -z "$(pgrep -x "$tool")" ]; then
mv --force "${logfile}.6" "${logfile}.7" 2>/dev/null
mv --force "${logfile}.5" "${logfile}.6" 2>/dev/null
mv --force "${logfile}.4" "${logfile}.5" 2>/dev/null
mv --force "${logfile}.3" "${logfile}.4" 2>/dev/null
mv --force "${logfile}.2" "${logfile}.3" 2>/dev/null
mv --force "${logfile}.1" "${logfile}.2" 2>/dev/null
mv --force "${logfile}" "${logfile}.1" 2>/dev/null
mv --force "${errfile}.6" "${errfile}.7" 2>/dev/null
mv --force "${errfile}.5" "${errfile}.6" 2>/dev/null
mv --force "${errfile}.4" "${errfile}.5" 2>/dev/null
mv --force "${errfile}.3" "${errfile}.4" 2>/dev/null
mv --force "${errfile}.2" "${errfile}.3" 2>/dev/null
mv --force "${errfile}.1" "${errfile}.2" 2>/dev/null
mv --force "${errfile}" "${errfile}.1" 2>/dev/null
echo "log-rotate done."
else
echo "log-rotate not possible."
fi;
}

do_showlog() {
echo "-------------------------------------------------------------------------------"
tail "$errfile"
echo "-------------------------------------------------------------------------------"
tail "$logfile"
echo "-------------------------------------------------------------------------------"
}


do_usage() {
echo "Usage: {start|stop|status|restart|logrotate|startdelayed|showlog}"
}

case "$1" in
start)
do_start
;;
stop)
do_stop
;;
status)
do_status
;;
restart)
do_restart
;;
startdelayed)
do_startdelayed
;;
logrotate)
do_logrotate
;;
showlog)
do_showlog
;;
*)
do_usage
;;
esac

exit 0
######################################################################################################

5. Reverse-Proxy Setup

You can run i2p-tools also behind your normal web-server (reverse-proxy).

The web-server handles the TLS handshake, encryption, SSL Certificate and the logfiles. But you don't need the scripts su3.php and the shell cronjob for creating su3-files. i2p-tools is running "behind" the web-server, without TLS management, only bind to local interface 127.0.0.1 and is handling complete building and handling of su3-files.

Run i2p-tools with this command: 

i2p-tools reseed --signer test@test.de \
                 --key /path_to/test_at_test.de.pem \
                 --netdb /path_to/netDb \
                 --port=8443 \
                 --ip 127.0.0.1 \
                 --trustProxy
Important notes for this special setup:
  • do *not* specify --tlsHost, --tlsCert or --tlsKey on the command-line
  • "ip 127.0.0.1" binds the program only to local interface
  • "trustProxy" uses the "X-Forwarded-For" to get the real client IP
"trustProxy" uses the "X-Forwarded-For" to get the real client IP

nginx configuration example: 

		location / {
			proxy_pass http://127.0.0.1:8443;
                        proxy_set_header X-Real-IP  $remote_addr;
                        proxy_set_header X-Forwarded-For $remote_addr;
		}

Apache (untested - feedback would be appreciated) 

		ProxyRequests Off
		<Proxy *>
			Order deny,allow
			Allow from all
		</Proxy>
		ProxyPass / http://127.0.0.1:8443/
		ProxyPassReverse / http://127.0.0.1:8443/

and for X-Forwarded-For: 

     proxy_set_header        X-Real-IP       $remote_addr;
     proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;

Additionally, ensure that your webserver uses these suggested settings for Strong SSL Security (visit CipherLi.st for the latest settings). A sample configuration is provided below.

Apache 

SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH
SSLProtocol All -SSLv2 -SSLv3
SSLHonorCipherOrder On
Header always set Strict-Transport-Security "max-age=63072000; includeSubDomains; preload"
Header always set X-Frame-Options DENY
Header always set X-Content-Type-Options nosniff
# Requires Apache >= 2.4
SSLCompression off 
SSLUseStapling on 
SSLStaplingCache "shmcb:logs/stapling-cache(150000)" 
# Requires Apache >= 2.4.11
SSLSessionTickets Off

nginx (remember to replace '$DNS-IP-1' & '$DNS-IP-2' with 2 trusted DNS servers) 

ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
ssl_ciphers "EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH";
ssl_ecdh_curve secp384r1; # Requires nginx >= 1.1.0
ssl_session_cache shared:SSL:10m;
ssl_session_tickets off; # Requires nginx >= 1.5.9
ssl_stapling on; # Requires nginx >= 1.3.7
ssl_stapling_verify on; # Requires nginx => 1.3.7
resolver $DNS-IP-1 $DNS-IP-2 valid=300s;
resolver_timeout 5s;
add_header Strict-Transport-Security "max-age=63072000; includeSubDomains; preload";
add_header X-Frame-Options DENY;
add_header X-Content-Type-Options nosniff;

Complete nginx configuration (sample) 

user nobody;
worker_processes 1;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;

    server {
        listen $IP_ADDRESS:443 ssl;
        server_name $DOMAIN;

        ssl_certificate keys/fullchain.pem;
        ssl_certificate_key keys/privkey.pem;

        ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
        ssl_ciphers "EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH";
        ssl_ecdh_curve secp384r1; # Requires nginx >= 1.1.0
        ssl_session_cache shared:SSL:10m;
        ssl_session_tickets off; # Requires nginx >= 1.5.9
        ssl_stapling on; # Requires nginx >= 1.3.7
        ssl_stapling_verify on; # Requires nginx => 1.3.7
        resolver $DNS_IP_1 $DNS_IP_2 valid=300s;
        resolver_timeout 5s;
        ssl_prefer_server_ciphers on;
        ssl_dhparam keys/dh.pem;
        server_tokens off;

        charset utf8;

        location /i2pseeds.su3 {
                proxy_pass http://127.0.0.1:8443;
                proxy_set_header X-Real-IP  $remote_addr;
                proxy_set_header X-Forwarded-For $remote_addr;
	  }
	}
}

6. Convert Existing Java Keystore to crt- and pem-file

This describes how to convert your existing Java keystore with your su3 signing key to a plain crt- and pem-file. This is only needed, when you already have a Java keystore and want to use Go solution. If you create new keys+certs with matt's solution you can skip this chapter!

Requirements:

  • Java keytool
  • openssl
  • and of course your secret password for the keystore

Keep in mind: the Java keystore has two passwords:

  • The secret key password you have entered while creating your keystore the first time (SU3File keygen ...)
  • And a "storage" password, which is most probably default "changeit".

This works in a Ubuntu/Debian shell: 

######################################################################################################
file="keystore.ks"
pass_jks=changeit

# List the keystore content, show the included (email) alias
keytool -list -storepass $pass_jks -keystore $file

# Convert jks --> pkcs12, specify the correct email alias (xxxxx@mail.i2p):
keytool -importkeystore \
        -srcalias xxxxx@mail.i2p \
        -srckeystore $file \
        -srcstoretype jks \
        -srcstorepass $pass_jks \
        -destkeystore ${file}.p12 \
        -deststoretype pkcs12 \
        -deststorepass $pass_jks \
        -destkeypass $pass_jks

# Show the pkcs12 content:
openssl pkcs12 -passin pass:$pass_jks -in ${file}.p12 -nodes -info

# Convert pkcs12 --> pem
openssl pkcs12 -passin pass:$pass_jks -in ${file}.p12 -nodes -out ${file}.pem

# Decrypt the pem
openssl rsa  -in ${file}.pem -out xxxxx_at_mail.i2p.pem

# Extract the certificate
openssl x509 -in ${file}.pem -out xxxxx_at_mail.i2p.crt
######################################################################################################

5. Seamless SSL-Certificate Exchange

The update/exchange of an already existing self-signed certificates has to be correct timed on server *and* client side. Considering thousands of clients (many with older I2P version) the exchange will not be seamless possible and will have very bad impact on many clients: reseed won't work for them.

To avoid this issue and make the exchange as smooth as possible follow these simple steps:

  1. Generate a new SSL-certificate NOW, but do NOT implement it on server
  2. Send the new SSL-certificate to us to perform a roll-out towards clients NOW
  3. WAIT some month, e.g. 3-4 i2p-releases
  4. New SSL-certificate is now hopefully present on many clients (in parallel to the current/old one)
  5. THEN exchange the SSL-certificate on server

This idea based on the fact, that you can provide in i2p/certificates/ssl more than one crt-file for a server, e.g. server.com.crt and server.com2.crt

6. Reseed Server Domain/URL/Port Exchange

You are already operating a reseed server but want to change your Domain/URL/Port? To make the exchange as smooth as possible for many clients please follow these steps if possible:

  1. Setup an additional reseed instance at the new Domain/URL/Port
  2. We include the new URL into I2P source NOW and delete the old URL NOW
  3. Both of your reseed instances have to run some time in parallel
  4. WAIT some month, e.g. 3-4 i2p-releases
  5. New URL is now hopefully present on many clients
  6. THEN shutdown the old reseed instance

7. Tests

Some simple pre-test: test the website and fetch 

	wget --user-agent="Wget/1.11.4" \
             -O /tmp/test.su3 \
             --no-check-certificate https://your-server.com:PORT/i2pseeds.su3
Replace "PORT" with default 443 or your chosen server setting. Inspect the fetched file.: Some simple pre-test: test the website and fetch 
	zipinfo -z /tmp/test.su3

Replace "--no-check-certificate" with "--ca-certificate=~/i2p/certificates/ssl/your-server.com.crt" which contains the path to your local public SSL-certificate to check also your ssl-certificate chain.

Confirm the following:

  • SSL-certificate chain valid?
  • The su3-files can be downloaded?
  • Contains > 50 dat-files?
  • And is always the same for one client-IP?
  • Other client-IP's gets another file?
  • Clients has no direct access to complete folder e.g. https://your-server.com/su3/ ?

Do a real reseed test on *another* I2P router machine:

  • Include manually new SSL-certificate into i2p installation: ~/i2p/certificates/ssl/
  • Include manually new public reseed key into i2p installation: ~/i2p/certificates/reseed/
  • http://localhost:7657/configreseed --> remove all reseed hosts
  • Add the new reseed host e.g. "https://your-server.com/" *without* trailing "i2pseeds.su3"
  • Save and Shutdown router.
  • Clear netdb: empty folder ./i2p/netDb.
  • Restart I2P and watch the I2P router log: 
    2014/10/13 23:01:02 | Reseed start
2014/10/13 23:01:02 | Reseeding from https://your-server/i2pseeds.su3
2014/10/13 23:01:05 | INFO: xx files extracted to /tmp/i2p-V2qudTbd.tmp/reseeds-1010682701
2014/10/13 23:01:05 | Reseed got xx router infos from https://your-server.com/i2pseeds.su3 with 0 errors
2014/10/13 23:01:06 | Reseed complete, xx received

8. Contact Reseed Maintainer

Contact us via email zzz at mail.i2p (alternatively, post in the reseed section on the zzz.i2p forum) Provide us with details about your new reseed server:

  • Reseed website URL
  • Public SSL certificate (Only required if selfsigned, which is not recommended. Please use Lets Encrypt or other CA)
  • Public reseed su3 certificate
  • Your contact email
  • A statement that you agree to the privacy policy above

Feel free to contact zzz at mail.i2p in case of questions or problems or post your question at zzz's forum in the reseed section.