Introduction

Tenfingers takes your files out of your computer and shares them with who you want, at all times.

Everything is encrypted and decentralised, assuring both privacy and accessibility of your data.

Make a blog or a website, share your latest photos, backup your data, send big files; all is possible with Tenfingers.

Share your link, and your friends will have access at all times, make it public and share with the whole world.

All it costs is some storage and some bandwidth for sharing, the rest is totally free. (FOSS GPL-3.0-or-later)

Basically:

You share data from others, because they share yours.

A simple and elegant incentive.

The default is oversharing, so many people will share your data, making it accessible at any time.

Installing is simple and quick:

Go here for instructions for Linux / Windows / Docker

Technically:

If you want more indepth information check out the Questios page or go online here

The more you share, automatically, the more you are shared!

This is all inbuilt in the protocol, there is no central power controlling anything, and everything is free.

By the way, this is the official Tenfingers logo:

Next step

Now you can go on to the Quick install Linux / Windows to set it up,

or go to the Prerequisite page to see more in depth what you need to set up Tenfingers manually.

Install

These are the available installs:

Linux

Windows

Docker

QuickInstall Linux

To set up and install Tenfingers on Linux, you only need to do these simple steps:

1: forward port 46000 to your PC

2: Download the install script:

curl -L -O https://codeberg.org/Valmond/Tenfingers/raw/branch/main/tenfingers/install_upgrade_linux.sh

3: Give it execution rights:

chmod +x ./install_upgrade_linux.sh

4: Run the script to set up Tenfingers and then subsequently to update it:

./install_upgrade_linux.sh

5: Connect to the node swarm:

10f --bootstrap

What's next?

For more: see Usage

QuickInstall Windows

To set up and install Tenfingers on Linux, you only need to do these two steps:

1: forward port 46000 to your PC

Download, configure and run Tenfingers:

Install python (https://www.python.org/downloads/windows/)
Install CryptoDomeX:

pip3 install pycryptodomex

Create a folder, for example a folder /Tenfingers/ on your desktop, so with USERNAME being your, you guessed it, user name, the folders full path is:

C:\Users\USERNAME\Desktop\Tenfingers\

In this folder, run:

git clone https://codeberg.org/Valmond/Tenfingers.git

or if you do not have git installed, go to https://codeberg.org/Valmond/Tenfingers and in the [...] menu, download a zipped version that you can unzip in your folder.

Add "C:\Users\USERNAME\Desktop\Tenfingers\Tenfingers\tenfingers" to PATH (this is where the python files live)

In the start menu, search for "PATH" and select "Edit the system environment variables"

Click [Environment Variables...]

Add it to the PATH variable

Note: commandline windows needs to be restarted for the new PATH variable to be detected

In a command line window, go to the folder you just added to PATH

cd "C:\Users\USERNAME\Desktop\Tenfingers\Tenfingers\tenfingers"

In that folder, run the setup:

python setup.py

In that folder, run:

python listener.py

to run the listener (you want to make this automatically at start up)

in that folder, make a file "10f.bat" and paste this into it:

python "C:\Users\USERNAME\Desktop\Tenfingers\Tenfingers\tenfingers\10f.py" %*

You can now type:

10f.bat

to use the 10f command line any where

Bootstrap

Download a test link

And in a freshly opened terminal (the PATH will not be found in the terminal if you just set it all up):

10f.bat testlink

Should download a testlink.txt and give your listener its first address.

Note:

Examples might use 10f which is a Linux alias, you will need to une 10f.bat instead because you are on windows.

For more: see Usage

Docker Install (experimental)

You can run the server part of Tenfingers in a simple docker container. This is easy and straightforward with only one caveat.

The problem with running the server in a docker is that it runs as a root user inside the container, and shared data is thus owned by the docker instance.

You can use chown to take ownership of files, but when manipulating the database, you will need superuser rights, or acquite those rights from the dockers root account. If you are not confident in doing so, you can run the docker with the local users permissions instead to avoid those problems:

Set up and run the docker with the local user

You must forward port 46000 to your PC like in the other types of install
Make a folder on your PC, for example on the desktop, then open it.
In that folder, make 4 folders:

mkdir db
mkdir data_shared
mkdir data_owned
mkdir translation_files

Make a file named docker-compose.yml

Paste this into it:

services:

  tenfingers:
    image: kingvalmond/tenfingers_server:1
    hostname: tenfingers

    # Use this if you do not want to get files owned by root (& in root group)
    # run id -u and id -g to find the UID and GID
    # Note, you will have to manually create the folders db, data_shared, data_owned and translation_files
    # in the same folder as this file
    user: "1000:1000"

    ports:  # The first port is the one exposed in your system, you need to forward this from your public IP address (do not change the second 46000 port)
      - 46000:46000

    volumes:  # LOCAL_MACHINE_FOLDER:DOCKER_FOLDER
      # The folders on the local machine will be created if not existsing (create them if you want user to own them)
      - ./db:/tenfingers/db
      - ./data_owned:/tenfingers/data_owned
      - ./translation_files:/tenfingers/translation_files
      - ./data_shared:/tenfingers/data_shared

Run the command id:

> id
uid=1000(username) gid=1000(username),4(adm),24(cdrom),27(sudo),30(dip),46(plu...

It shows your user id and group id for users, get yours (here it is 'username') and update the numbers:

user: "1000:1000"

in the docker-compose.yml file and save.

Note: the first number is the user id (uid), the second is the group id (gid).

Start the server:

docker compose up

Congratulations, the server is now up and running!

Part 2, the user interface

Now that the server part is up and running, you need to interact with it, or it will not be very useful at all.

Download the python files

git clone https://codeberg.org/Valmond/Tenfingers.git
mv ./Tenfingers/tenfingers/*.py ./
rm -rf ./Tenfingers

Note: you can use this again to update the python files if a new version is out.

Bootstrap the server node (so it can connect to the node swarm)

Now you can download the test link from the official website or just get it directly on the command line:

curl https://www.mindoki.com/10f/testlink.10f -o testlink.10f

Use it:

python3 10f.py testlink

It should download and produce a file:

testlink.txt

And the /db/tenfingers.db should now have a node address in it (you need a SQLite reader to visualise the /db/tenfingers.db file).

There you are, all set up and running, bravo!

Now you can add files, make links and share content but beware, a key difference with the docker install is that you do not have access to the '10f' command everywhere on your machine, so to use commands you must be in the folder with the python files and precede commands with 'python3 10f.py'.

So when you see, for example:

10f -i my_stuff_to_share image.jpg

in the documentation, you will have to do:

python3 10f.py -i my_stuff_to_share image.jpg

Note: the key_* files in /db/ are what makes your node recognisable and unique, you would want to backup them. To restore, just put them in the /db/ folder before you run the server image.

#Install Tenfingers

This is the older more thorough explication on how to install Tenfingers:

Go to: Prerequisite

Prerequisite

You need to either use Python, or the Frozen executables, and their prerequisites are as follows:

Python: Python3 and CryptodomeX

You need Python 3.6 or better plus the library pycryptodomex.

To install Python, see install recommendations for your specific OS.

If you don't know if python is installed or which version is installed, use:

python3 --version

When you have Python 3.6 or better installed, you need to install CryptodomeX.

Just run:

pip3 install pycryptodomex

Frozen executables: No specific prerequisites.

If you can't or don't want to use Python, then you can use the frozen executables instead.

This does not need python (or CryptoDome, it's baked in in the executables), you just run the executables as is.

The Linux executables has been built on a Linux Mint 21 setup, if you have trouble on another Linux OS, use the python version.

Just use the pre-frozen executables for your specific operative system.

Note: On Windows, newly frozen executables sometimes get flagged as dangerous files. Just don't use them.

Next step

Install Tenfingers

Installing/setup Tenfingers manually

Get the tenfingers files

You may use python or frozen executables:

Linux Python:

You can get the latest version from git:

These commands will create a tenfingers folder in your HOME folder and download the python files into it.

# Go to your users home folder (you can put it anywhere, it's just convenient to have it here)
cd $HOME
# Make a fonder for Tenfingers
mkdir tenfingers
cd tenfingers
# Get the git repositorys content
git clone https://codeberg.org/Valmond/Tenfingers.git
# Get only the python files
mv Tenfingers/tenfingers/*.py ./
mv Tenfingers/tenfingers/*.sh ./
# Remove the rest
rm Tenfingers -rf

Run the setup:

python3 ./setup.py

Windows Python:

Download the latest version here.

Extract it and go to /tenfingers_release/py_source and get the python files.

Put them in any folder you want, or use them where they already are.

Run the setup:

python3 setup.py

Linux or Windows frozen executables:

Download the latest version for your OS from tenfingers.org

Download for Linux

Download for Windows

Extract it and go to /tenfingers_release/bin and get all the executables.

Put them in any folder you want, or use them where they are.

Run the setup:

Linux:

./setup

Windows:

setup.exe

Note for Linux and Windows Frozen executable users:

Further on the examples will be for Python on Linux, so you might need to adjust them a little.

So for example, in an example for Linux with Python:

python3 ./10f.py test ...

it becomes, on Linux (without python):

./10f test ...

and on Windows (without Python):

10f.exe test ...

and on Windows with Python:

python 10f.py test ...

Forwarding internet to your PC and start the node

You now need to forward a port from internet to your PC, for example the default port 46000.

This is usually made in the software of your internet proveders "box", or your router.

This is the complicated part, get this up and running and everything else should be quite simple! Good luck.

You will also need to have your public IP address, say for example your public IP is 173.77.77.77

The setup tries to figure out your public IP address, check if it got it right:

python3 ./10f.py -p

This will show all the configurations, check ip is set to "173.77.77.77"

If you need to change is:

python3 ./10f.py -p ip 173.77.77.77

In the same way, if you don't use the default 46000 port, but say port 8080

python3 ./10f.py -p port 8080

You need to restart the listener after IP or PORT changes.

When the listener is running (see below), but not before, you can check if the configuration is working:

python3 ./10f.py -test

Run the listener

You might want to use another shell to run the listener but anyway you start it like this:

python3 ./listener.py

On Linux que can setup the listener to run automatically byy adding it to the crontab:

crontab -e

then add the line:

@reboot cd ~/Tenfingers/tenfingers && python3 ./listener.py&

Where ~/Tenfingers/tenfingers is where the python files are located.

Now the Tenfingers listener will start automatically after each reboot.

You can check if the listener is tunning using this command:

lsof -i tcp:46000

Bootstrap the node swarm

If you have all set up, and the listener running, you still need to give it access to the tenfingers network.

Download a test link

and then use 10f to download a small smample file from the network:

Linux:

./10f ./testlink.10f

Linux python:

python3 ./10f.py ./testlink.10f

Windows:

10f.exe testlink.10f

Windows python

python3 10f.py testlink.10f

Next step

Now that you are all set (felicitations, you got it all up and running!), see the next step Usage for how to share data: Usage

Usage

Sharing data is simple, just add the data, create a link and you're done:

Share a photo:

10f -i my_stuff_to_share image.jpg

Create the link files:

10f -c my_stuff_to_share

Now anyone having the link files can download your photo!

Note: the _tr.10f and _sub.10f files are only needed if you want to share your file for a very long time.

You can then update the data, and the user can download the new data:

10f -i my_stuff_to_share image_2.jpg

To share a folder, say ./images/ just add -f

10f -i -f my_stuff_to_share images

If you only want to share .jpg images in the ./images/ folder, you can add a regex:

10f -i -f my_stuff_to_share images .\.jpg

To check out what you have already shared:

10f -l

or a more thorough list:

10f -la

Note: The number of 'fingers' is how many times your data is shared by other tenfinger nodes.

Using a link file and download the data from it:

So you just got my_stuff_to_share.10f from a friend, to check it out just:

10f my_stuff_to_share

and the shared data will be downloaded.

Help

There is an inbuilt help that you can use like this:

10f -h

And if you want some help with a specific command, like inserting for example ( -i )

10f -h -i

List all available commands with:

10f -list

Stuck or curious? Go here for more information and help.

Questions and answers

What is Tenfingers and how does it work?

Install it, forward a port and you can now share your data with any one, at any time, for free.

Like a personal website for anyone to see, or sharing your holiday photos with your friends only.

Some random technical details please!

Tenfingers uses a trust less node swarm

You launch a listener that, with the help of a first link, connects to a loosely connected trust-less node swarm.

Basic handshake goes over RSA 4096 and then everything else is over AES 256-CTR.

The sharing is made reciprocally, with a default over sharing of 10 times (so ten nodes will hold and serve your data while you share data from those ten nodes).

Two extra tenfingers files are shared with the link (a translation file, and a substitution file) to prevent link decay. Share them alongside the link file if the longevity of the data shared is important.

A link works forever, and still works perfectly well if you update your shared data, it's built exactly for that.

I want to ask more questions!

If you didn't find what you were looking for, or you want to contribute, you can come here, it's on the fediverse!

More and diverse information

This is mostly work in progress and experimental stuff, they might not work!

Check out and enjoy.

Weekend Projects

Here I have gathered some less quality projects, made quickly to test the network and to see what it can be useful for.

Take the projects as a learning experience, it's a mix of shell commands and python, made with the intent to teach whenever possible. This is not always a success of course.

Note: those are mostly made for Linux with Python, but can surely be tweaked easily.

Creating your book: (Linux)

Note: this is just an example, feel free to change anyting to your convenience

Note: this is not optimized at all and merely an example for what can be done using the tenfingers sharing protocol.

Create a folder that will contain your lifes story, say /home/loulou/Desktop/TenfingersBook/my_book

In there, create a folder of todays date: 20240930

In there put a file: what i did today.txt and fill it with your thoughts. Maybe you'd like to add a photo?

Go to the base folder (here : /home/loulou/Desktop/TenfingersBook/my_book ) and run this script:

Note: you need to change the TENFINGERS_SRC_DIR variable so it points to where 10f.py lives

#!/usr/bin/bash
# Modify these:
# Where you can find the 10f.py file (and all the other python files)
TENFINGERS_SRC_DIR=${HOME}/tenfingers
# The name of the book you want to create
BOOK_NAME="my_book"
# Where your book is (this folder should contain folders, who themselves contains files)
BOOK_DIR=${HOME}"/Desktop/TenfingersBook"

######################################
# Do not modify these:
cd $TENFINGERS_SRC_DIR
python3 tenfingers_book.py $BOOK_NAME $BOOK_DIR

Run it and you should create three files:

my_book.10f
my_book_tr.10f
my_book_sub.10f

Those are the files you can now send to people who you want to share your wisdom with!

When you have updated your book, just run the script again, and that's it!

Checking ouy your book

So someons just sent you three files:

my_book.10f
my_book_tr.10f
my_book_sub.10f

What should I do with them?

Simple, just make some folder somewhere, put them there and run this script:

Note: you need to change the TENFINGERS_SRC_DIR variable so it points to where 10f.py lives

#!/usr/bin/bash
# Modify these:
# Where you can find the 10f.py file (and all the other python files)
TENFINGERS_SRC_DIR=${HOME}/tenfingers
# The name of the book you want to get (the name of the shortest 10f file)
BOOK_NAME="my_book"

######################################
# Do not modify these:
mkdir -p $BOOK_NAME
cd $BOOK_NAME
rm *.10f  2> /dev/null
cp ../my_book.10f my_book.10f
cp ../my_book_tr.10f my_book_tr.10f
cp ../my_book_sub.10f my_book_sub.10f

TENFINGERS_PY="${TENFINGERS_SRC_DIR}/10f.py"
TENFINGERS_BOOK="${BOOK_NAME}.10f"

python3 $TENFINGERS_PY $TENFINGERS_BOOK

# Clean up
rm "${BOOK_NAME}.10f"
rm "${BOOK_NAME}_tr.10f"
rm "${BOOK_NAME}_tr.atf"
rm "${BOOK_NAME}_sub.10f"
rm "${BOOK_NAME}_sub.atf"

# Get all the chapters:
echo "Get all the chapters"
for file in *.10f; do
    if [ -f "$file" ]; then
        no_extension=${file::-4}
        if [[ $no_extension =~ .(_tr|_sub)$ ]]; then
            #echo "tr/sub file, skipping"
            :
        else
            echo "Get chapter $file"
            python3 $TENFINGERS_PY $file
        fi
    fi
done

# Clean up
rm *.10f  2> /dev/null
rm *.atf  2> /dev/null

Open the index.htm file, and voilà !

A Chat program

Chat with your friends and family!

The chat code needs tkinter, which I foolishly thought was integreated with python.

sudo apt-get install python3-tk

Then you can start the chat_gui.py like this, in the python folder:

python3 chat_gui.py

Diverse stuff

Here I will list lesser needed information, experimental stuff and things I do not yet know what to do with.

There is an inbuilt help function:

10f -h

If you want help with a specific command, say for example insert ( -i ) just add that:

10f -h -i

The git repo is here :

https://codeberg.org/Valmond/Tenfingers

DEPRECATED: You can use the 10f frozen executable alone to download 10f link files.

There is an experimental GUI you can use together with the python installation, it lets you do basic things like upload and download and set parameters.

Just download and run the start_gui.sh in your tenfingers python folder.

You can get it here in the git repositorys script folder

The number of fingers is how many nodes shares your data, it might take some time to find nodes that wants to share your data, especially if the data is big!

Small files are often shared pro bono, the default is that files up to 64KB is stored for free, up to a total of 64MB.

A special thank you to Beej and his extraordinary book: Beej's guide to network programming. Never met him but the book is a must have for any network curius programmer!

If you want to make a chat program, a backup soft or any other kind of tech based on Tenfingers, you might want to check out the python file 'access.py' which contains some simplified functions to do basic things like inserting data or downloading.

Legal

Please see subsections

Legal

Sources and files

All sources are distributed under the GPL-3.0-or-later licence.

I do not take any kind of responsibility if/when you use these files in whatever way.

I do not take any kind of responsability for any information on this page either.

Usage of the tenfingers software

Here node and server can be used interchangeably, it designes the sharing software.

Do not use this software to propagate or share illegal content.

You are required to remove illegal content from your system if you get a takedown request.

As the node do not know what it is sharing, the node should be under the Safe Harbour Provision and thus not legally obliged to know what it is sharing, but this also implies that any takedown requests must be fullfilled.

This means you have to swiftly comply with takedown requests, and remove any illegal content on your server that you are aware of.

Takedown Requests

How to generate a takedown request.

If you want to make a takedown request for a file: example_file.10f

then you will need to execute the following steps:

10f --takedown-generate example_file

This will generat two files:

example_file.address

example_file.takedown

In the example_file.address file you will find all the IP addresses who serve the data for example_file.10f

You will need to contact the owners of those IP addresses and send them the second file; example_file.takedown

They can now comply with the takedown request by executing the takedown file on their sysytem, and the data will be deleted.

How to execute a takedown reques on your server.

If you recieve a takedown request, it is quite easy to comply:

Lets say that the file example_file.takedown has been sent to you with a request for takedown.

To comply, you just need to execute it:

10f --takedown-execute example_file.takedown

This will remove the data served by example_file.10f

To verify that the file has actually been removed, you can use:

10f --takedown-verify example_file.takedown

Whitepaper

You can find a more thorough explanation about the protocol in the Whitepaper