0bin’s documentation¶

0bin is a client side encrypted pastebin that can run without a database.

Try it: 0bin.net
Get the source on github

English Français

Introduction¶

0bin allows anybody to host a pastebin while welcoming any type of content to be pasted in it. The idea is that one can (probably...) not be legally entitled to moderate the pastebin content as he/she has no way to decrypt it.

It’s an Python implementation of the zerobin project. It’s easy to install even if you know nothing about Python.

How it works¶

When creating the paste:

the browser generate a random key;
the pasted content is encrypted with this key using AES256;
the encrypted pasted content is sent to the server;
the browser receives the paste URL and add the key in the URL hash (#).

When reading the paste:

the browser makes the GET request to the paste URL;
because the key is in the hash, the key is not part of the request;
browser gets the encrypted content et decrypt it using the key;
the pasted decrypted content is displayed and code is colored.

Key points:

because the key is in the hash, the key is never sent to the server;
therefor it won’t appear in the server logs;
all operations, including code coloration, must happens on the client;
the server is no more than a fancy recipient for the encrypted data.

Other features¶

automatic code coloration (no need to specify);
pastebin expiration: 1 day, 1 month or never;
burn after reading: the paste is destroyed after the first reading;
clone paste: you can’t edit a paste, but you can duplicate any of them;
code upload: if a file is too big, you can upload it instead of using copy/paste;
copy paste to clipboard in a click;
get paste short URL in a click;
own previous pastes history;
visual hash of a paste to easily tell it apart from others in a list;
optional command-line tool to encrypt and paste data from shell or scripts.

Technologies used¶

Python
The Bottle Python Web microframework
SJCL (js crypto tools)
jQuery
Bootstrap, the Twitter HTML5/CSS3 framework
VizHash.js to create visual hashes from pastes
Cherrypy (server only)
node.js (for optional command-line tool only)

Known issues¶

0bin uses several HTML5/CSS3 features that are not widely supported. In that case we handle the degradation as gracefully as we can.
The “copy to clipboard” feature is buggy under linux. It’s flash, so we won’t fix it. Better wait for the HTML5 clipboard API to be implemented in major browsers.
The pasted content size limit check is not accurate. It’s just a safety net, so we thinks it’s ok.
Some url shorteners and other services storing URLs break the encryption key. We will sanitize the URL as much as we can, but there is a limit to what we can do.

What does 0bin not implement?¶

Request throttling. It would be inefficient to do it at the app level, and web servers have robust implementations for it.
Hash collision prevention: the ratio “probability it happens/consequence seriousness” is not worth it
Comments: it was initially planed. But comes with a lot of issues so we chose to focus on lower handing fruits.

Easiest installation¶

These solution are easy all will be able to handle a personnal website traffic. For more robust and secure solutions, see Apache and Nginx setups.

10 seconds setup (if you know Python already)¶

Just type:

pip install zerobin
zerobin --host 0.0.0.0 --port 80 --compressed-static # as admin

30 seconds setup (for anybody)¶

Make sure you have Python 2.7 or 3.4+ (python –version)
Download the last zip of the source code
Extract all of it where you wish the site to be stored.
Go to the extracted files.

Run with the admin rights:

python zerobin.py --host 0.0.0.0 --port 80 --compressed-static

On ubuntu, this is a one liner:

wget stuff && unzip zerobin.zip && cd zerobin && sudo python zerobin.py --host 0.0.0.0 --port 80 --compressed-static

Check out for more configuration options.

Run 0bin in background¶

0bin doesn’t come with something built in for this. You have several solutions.

For a small website:

Just make it a shell background process. E.G in GNU/Linux:

nohup python zerobin.py --host 0.0.0.0 --port 80 --compressed-static &

Or run it in a screen.

For a big Website:

setup 0bin with Apache;
setup 0bin with supervisor (best way to do it).

Note

You can even use zerobin on your private local network from your laptop.

Make sure you firewall won’t block the port, and run:

python zerobin.py --host 0.0.0.0 --port 8000

0bin will now be accessible from http://your.local.ip.address:8000.

This can be very cool way to share code in a companie or during a code sprint.

Apache setup¶

Note

You need to have followed the easy install first.

Apache is heavier than Nginx. But it’s also much more famous:

more people will be able to help you on forums;
your hosting will most probably support Apache;
the configuration file syntax is familiar to a lot of people.

An Apache setup is still much more robust and secure than an easy installation.

Une installation apache est aussi beaucoup plus solide et sécurisé qu’une installation facile. You’ll benefit from having:

the possibility to have several projects listening to the port 80;
several Apache module at your disposal (like requests throttling);
Apache robustness in front end: it’s secure, and there is much less chance it will crash under heavy load;
your web site processes won’t run with admin rights, even if –user doesn’t work on your OS.

Mod_wsgi¶

The modern Web Python servers all work the same way, following an norm for interfacing: WSGI.

This is the most performante solution, and the best to use. But it will require the setup of the Apache module mod_wsgi. If you don’t know how to do this, or if you can’t do it (E.G: your hosting won’t let you), you need to go for the CGI setup.

First, make sure you have mod_wsgi installed and enable by running (as admin):

a2enmod wsgi

This enable mod_wsgi. It it doesn’t, install it first (on ubuntu, the package is libapache2-mod-wsgi).

Then create an Apache configuration file, usually in /etc/apache/sites-available/. Name it zerobin:

<VirtualHost *:80>
    ServerName www.yourwebsite.com

    WSGIDaemonProcess zerobin user=www-data group=www-data processes=1 threads=5
    WSGIScriptAlias / /path/to/zerobin/app.wsgi

    <Directory /path/to/zerobin/zerobin/>
        WSGIProcessGroup zerobin
        WSGIApplicationGroup %{GLOBAL}
        Order deny,allow
        Allow from all
    </Directory>
</VirtualHost>

Activate the website (as admin):

a2ensite zerobin

And reload the apache configuration (as admin):

service apache2 reload

You’ll note that we refer to a file named app.wsgi. It’s a Python file creating the application Apache is going to use to start the Python process:

import os, sys

# make sure the zerobin module is in the PYTHON PATH and importable
ZEROBIN_PARENT_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.insert(0, ZEROBIN_PARENT_DIR)

# create the wsgi callable
from zerobin.routes import get_app
settings, application = get_app(compressed_static=True)

You can of course create your own, as the get_app function is the only way to pass settings to 0bin with this setup. You would do this by creating a configuration file and passing it to the function:

import os, sys

ZEROBIN_PARENT_DIR = '/path/to/zerobin/parent/dir'
sys.path.insert(0, ZEROBIN_PARENT_DIR)

from zerobin.routes import get_app
settings, application = get_app(settings_file='/path/to/settings.py')

CGI¶

You can also run 0bin using CGI, but infortunaly we didn’t have time to cover it yet. Please contact us if you ever get the need to use it.

Nginx setup¶

Note

You need to have followed the easy install first.

Nginx is a very popular choice to serve a Python project:

It’s fast.
It’s lightweight.
Configuration files are simple.

If you have your own server, it’s the best choice. If not, try the: easiest setup, or the Apache setup.

Nginx doesn’t run any Python process, it only serve requests from outside to the Python server.

Therefor there are two steps:

Run the Python process.
Run Nginx.

You will benefit from having:

the possibility to have several projects listening to the port 80;
several Apache module at your disposal (like requests throttling);
Apache robustness in front end: it’s secure, and there is much less chance it will crash under heavy load;
your web site processes won’t run with admin rights, even if –user doesn’t work on your OS;
the ability to manage a Python process without touching Nginx or the other processes. It’s very handy for updates.

The Python process¶

Run 0bin as usual, but this time make it listen to a local port and host. E.G:

zerobin --host 127.0.0.1 --port 8000

In PHP, when you edit a file, the changes are immediately visible. In Python, the whole code is often loaded in memory for performance reasons. This means you have to restart the Python process to see the changes effect. Having a separate process let you do this without having to restart the server.

Nginx¶

Nginx can be installed with you usual package manager, so we won’t cover installing it.

Vous must create a Nginx configuration file for 0bin. On GNU/Linux, they usually go into /etc/nginx/conf.d/. Name it zerobin.conf.

The minimal configuration file to run the site is:

server {
    listen       80;
    server_name www.yourwebsite.com;

    location / {
        proxy_pass http://127.0.0.1:8000;
    }
}

proxy_pass just passes the external request to the Python process. The port much match the one used by the 0bin process of course.

You can make some adjustements to get a better user experience:

server {
    listen       80;
    server_name www.yourwebsite.com;

    location /favicon.ico {
        root  /path/to/zerobin/static/img;
    }

    location /static/ {
        root  /path/to/zerobin;
        gzip  on;
        gzip_http_version 1.0;
        gzip_vary on;
        gzip_comp_level 6;
        gzip_proxied any;
        gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;
        gzip_buffers 16 8k;
        # Disable gzip for certain browsers.
        gzip_disable ~@~\MSIE [1-6].(?!.*SV1)~@~];
        expires modified +90d;
    }

    location / {
        proxy_pass http://zerobin_cherrypy;
    }
}

This make Nginx serve the favicon and static files, set the expire HTTP headers and make sure gzip compression is used with browsers that support it.

Using supervisor¶

Supervisor is a very nice way to manage you Python processes. We won’t cover the setup (which is just apt-get install supervisor or pip install supervisor most of the time), but here is a quick overview on how to use it.

Create a configuration file named supervisor.ini:

[unix_http_server]
file=/tmp/supervisor.sock;

[supervisorctl]
serverurl=unix:///tmp/supervisor.sock;

[rpcinterface:supervisor]
supervisor.rpcinterface_factory=supervisor.rpcinterface:make_main_rpcinterface

[supervisord]
logfile=/tmp/zerobin.log
logfile_maxbytes=50MB
logfile_backups=2
loglevel=trace
pidfile=/tmp/supervisord.pid
nodaemon=false
minfds=1024
minprocs=200
user=zerobin

[program:zerobin]
command=/path/to/zerobin/zerobin.py --port 80 --compressed-static
directory=/path/to/zerobin/
environment=PYTHONPATH='/path/to/zerobin/'
user=zerobin
autostart=true
autorestart=true

The 4 first entries are just boiler plate to get you started, you can copy them verbatim.

The last one define one (you can have many) process supervisor should manage.

It means it will run the command:

/path/to/zerobin/zerobin.py --port 80 --compressed-static

In the directory, with the environnement and the user you defined.

This command will be ran as a daemon, in the background.

autostart and autorestart just make it fire and forget: the site will always be running, even it crashes temporarly or if you retart the machine.

The first time you run supervisor, pass it the configuration file:

supervisord -c /path/to/supervisor.ini

Then you can manage the process by running:

supervisorctl -c /path/to/supervisor.ini

It will start a shell from were you can start/stop/restart the service

You can read all errors that might occurs from /tmp/zerobin.log.

Note

If you installed zerobin in a virtualenv, you may set the command to run directly from it:

command=/path/to/virtualenv/bin/zerobin --port 80 --compressed-static

Theming¶

0bin comes with a complete theming support, but for now it’s not well integrated.

If you wish to create your own theme, you’ll need to create templates similar to the ones in zerobin/view, and add the path to the directory containing them to the configuration file.

You’ll also need to copy static files from zerobin/static to a new directory where you can edit them. And you need to add this directory in the configuration file too.

Of course, if you look for something simple, you can just edit all files in place/

But be careful, the javascript code is tightly coupled with HTML ID and classes, and they are not very well organized for now.

If you have serious theming needs, please contact us so we improve the support.

Options¶

0bin’s behavior can be adjusted with options passed using a configuration file or directly using the command line. Some parameters are only available in the configuration file.

If an option is not passed, 0bin will use the default value from the file zerobin/default_settings.py.

Command line¶

–host and –port¶

The host and port on which to listen for incomming request. Usually 127.0.0.1 and 8000 to listen locally or 0.0.0.0 and 80 to listen from the outside.

Default: 127.0.0.1 and 8000

Setting file : HOST and PORT

–debug¶

Display a listing of useful debugging information when something goes wrong instead of showing the 500 error page.

In debug mode, the server also reload automatically any modified Python file;

Default: False

Configuration file equivalent: DEBUG

–user and –group¶

The user and group the server will adopt after start up.

Useful when you run the command with admin rights to be able to listen to the port 80, but you wish that the process do not have access to protected files.

–group is set to –user if not passed.

Default: None

Configuration file equivalent: USER and GROUP

–settings-file¶

Path to the configuration file, if you use any.

Default: None

Configuration file equivalent: None

–compressed-static¶

Serve minified static files (css and js). Use it in production to get a faster web site.

Default: False

Configuration file equivalent: COMPRESSED_STATIC_FILES

–version and –help¶

Display the help or the version of 0bin.

Default: None

Configuration file equivalent: None

Examples¶

Production:

sudo zerobin --host 0.0.0.0 --port 80 --user foo --compressed-static

Developpement:

zerobin --debug --serve-static

Configuration file¶

The configuration file should be an ordinary Python file, usually named settings.py. It’s used this way:

zerobin --settings-file '/path/to/settings.py'

Any options passed to the command line will have priority on the ones in the configuration file. The zerobin/default_settings.py can be used as an example to create your own file. It’s heavily commented.

DEBUG¶

Display a listing of useful debugging information when something goes wrong instead of showing the 500 error page.

In debug mode, the server also reload automatically any modified Python file;

Default: False

Command line equivalent: –debug

STATIC_FILES_ROOT¶

Asbolute path to the directory where 0bin is going to look for static files (css, js and images).

Default: “static” directory in the “zerobin” directory

Command line equivalent: None

COMPRESSED_STATIC_FILES¶

Serve minified static files (css and js). Use it in production to get a faster web site.

Default: False

Command line equivalent: –compressed-static

PASTE_FILES_ROOT¶

Absolute path to the directory in which 0bin is going to look save pastes.

Default: “static/content” direcotry in the “zerobin” directory

Command line equivalent: None

TEMPLATE_DIRS¶

List of absolute path to directories containing templates that 0bin uses to generate the web site pages. The first list items have priotity on the later.

If you wish to use your own templates, add the directory containing them at the beginning of the list:

from zerobin.defauls_settings import TEMPLATE_DIRS

TEMPLATE_DIRS = (
    '/directy/path/to/your/templates',
) + TEMPLATE_DIRS

Default: “view” directory in the “zerobin” directory

Command line equivalent: None

HOST and PORT¶

The host and port on which to listen for incomming request. Usually 127.0.0.1 and 8000 to listen locally or 0.0.0.0 and 80 to listen from the outside.

Default: 127.0.0.1 and 8000

Configuration file equivalent: –host and –port

USER and GROUP¶

The user and group the server will adopt after start up.

Useful when you run the command with admin rights to be able to listen to the port 80, but you wish that the process do not have access to protected files.

GROUP is set to USER if not passed.

Default: None

Configuration file equivalent: –user and –group

MAX_SIZE¶

Approximative value for a paste size limite.

Valeur approximative de limite de taille d’un paste.

Default = 500000 octets (500 ko)

Command line equivalent: None

zerobinpaste command-line tool¶

zerobinpaste is a simple CLI tool (analogous to pastebinit or wgetpaste) to use with files or shell redirection in terminal or simple scripts.

Example use-cases might look like:

% zerobinpaste README.rst
http://some.0bin.site/paste/0cc3d8a8...

% grep error /var/log/syslog | zerobinpaste
http://some.0bin.site/paste/81fd1324...

% zerobinpaste docs/en/*.rst
easy_install.rst http://some.0bin.site/paste/9adc576a...
apache_install.rst http://some.0bin.site/paste/01408cbd...
options.rst http://some.0bin.site/paste/921b2768...
...


% ps axlf | zerobinpaste | mail -s "Process tree on $(date)" root

Produced links can then be copy-pasted to some IRC channel or used in whatever other conceivable way.

Tool does encryption by itself on the client machine and key (after hashmark) is never sent to server or anywhere but the tool’s stdout stream (e.g. terminal).

Tool has to be built with node.js separately (see below).

Usage¶

At least the pastebin site (main URL where you’d paste stuff with the browser) has to be specified for the tool to use either via -u (–url) option (can be simplified with shell alias - e.g. alias zp='zerobinpaste -u http://some.0bin.site) or in the “~/.zerobinpasterc” configuration file (json format).

Non-option arguments are interpreted as files to upload/paste contents of.

If no arguments are specified, data to paste will be read from stdin stream.

Simple configuration file may look like this:

{“url”: “http://some.0bin.site“}

Any options (in the long form, e.g. “url” for –url above) that are allowed on the command-line can be specified there.

Run the tool with -h or –help option to see full list of supported parameters.

Build / Installation¶

In essence:

0bin% cd tools 0bin/tools% make ... 0bin/tools% cp zerobinpaste ~/bin # install to PATH

“npm” binary (packaged and installed with node.js) is required to pull in build dependencies, if necessary, and “node” binary is required for produced binary to run.

Use “make” in “tools” path to produce non-minified runnable “zerobinpaste” script there.

make ugly command can be used instead of make to create “minified” version (using/installing uglifyjs, about 25% smaller in size).

Resulting “zerobinpaste” script requires only node.js (“node” binary) installed to run and can be placed in any of the PATH dirs (e.g. “~/bin”, “/usr/local/bin”) to be run just as “zerobinpaste”.

Why node.js and not python¶

Unfortunately, it’s fairly complex and unreliable to replicate non-trivial and undocumented encryption protocol that SJCL convenience methods employ, and any mistake in encryption is guaranteed to produce unreadable paste.

Current implementation uses same JavaScript code (and V8 node.js engine) that browsers do, hence can be fairly simple and robust.

Future development plans include supporting configurable, less complex and more widespread encryption schemas, allowing for simplier non-javascript client as well.

See related pull request for more details.

Report a bug

Introduction¶

0bin permet à tout à chacun d’héberge un pastebin tout en acceptant que n’importe quel type de contenu y soit posté. L’idée est qu’une personne ne peut (probablement...) pas être tenue de modérer le contenu du pastebin si elle n’a aucun moyen de le déchiffrer.

C’est une implémentation en Python du projet zerobin, facile à installer même si on ne connait pas ce langage.

Comment ça marche¶

A la création du paste:

le navigateur génère une clé aléatoire;
le contenu est chiffré avec une clé en utilisat AES256;
le contenu chiffré est envoyé au serveur;
le navigateur reçoit l’URL du paste et ajoute la clé dans le hash (#) de l’URL

A la lecture du paste:

le navigateur fait une requête GET avec l’URL du paste;
puisque la clé est das le hash, la clé ne fait pas partie de la requête;
le navigateur récupère le contenu chiffré et le déchiffre en utilisant la clé;
le contenu est affiché en clair et le code coloré.

Points clés:

la clé n’est jamais envoyé au serveur car elle est stocké dans le hash;
et donc la clé n’apparaitra pas dans les logs du serveur;
toutes les opérations, y compris la coloration syntaxique, se font côté client;
le serveur n’est rien d’autre d’un conteneur pour les données chiffrée.

Autres fonctionalités¶

coloration syntaxique automatique (pas besoin de la spécifier);
expiration du pastebin: 1 jour, 1 mois, jamais;
autodesctruction: le paste est détruit à la première lecture;
clone d’un paste: pas d’édition possible, mais on peut dupliquer un paste;
upload du code: si le fichier est gros, on peut l’uploader d’un coup plutôt qu’utiliser le copier/coller;
copier dans le presse papier tout le code en un click;
raccourcir l’url du paste en un click;
historique des ses propres pastes précédents;
hash visuel du paste pour l’identifier facilement dans une liste.

Technologies utilisées¶

Python
The Bottle Python Web microframework
SJCL (js crypto tools)
jQuery
Bootstrap, le framework HTML5/CSS3 de Twitter
VizHash.js pour créer les hash visuels des pastes
Cherrypy (serveur uniquement)

Problèmes connus¶

0bin utilise plusieurs fonctionalités HTML5/CSS3 qui ne sont pas encore largement supportées. Dans ce cas nous gérons la dégradation le plus gracieusement possible.
La fonction “copier dans le press/papier” est buggée sous Linux. C’est du flash donc nous ne le réparerons pas. Il vaut mieux attendre le support du presse papier via l’API HTML5.
La vérification de la limite de ta taille du paste n’est pas précise. c’est juste un filet de sécurité, donc nous pensons que ça suffira.
Quelques raccourcisseurs d’URL et d’autres services cassent la clé de chiffrement. Nous essayerons de nettoyer autant que possible mais il y a une limite à ce que nous pouvons faire.

Qu’est-ce que 0bin ne fait pas ?¶

Limitation du nombre de requêtes: ce serait peu productif de le faire au niveau de l’application alors que les serveurs Web le font tous de manière très efficace.
La prévention de collision de hash: le ratio “occurence/conséquence” n’est pas suffisant.
Commentaires: c’était prévu. Mais il y a beaucoup de contraintes associées, nous avons donc choisi de nous concentrer sur les fonctions avec un meilleur rapport qualité/prix.

Installation la plus simple¶

Ces solutions sont simples et supportent le traffic d’un site web personnel. Pour des solutions plus solides et sécurisées, essayez les installation Apache et Nginx.

Installation en 10 secondes (si vous connaissez Python)¶

Entrez:

pip install zerobin
zerobin --host 0.0.0.0 --port 80 --compressed-static # en tant qu'admin

Installation en 30 secondes (pour tous)¶

Assurez-vous d’avoir Python 2.7 ou 3.4+ (python –version)
Télécharger le dernier zip du code source.
Décompressez tous les fichiers là où vous souhaitez mettre le site.
Allez dans les dossiers extraits.

Lancez avec les droits admin:

python zerobin.py --host 0.0.0.0 --port 80 --compressed-static

Sous ubuntu, une line suffit:

wget stuff && unzip zerobin.zip && cd zerobin && sudo python zerobin.py --host 0.0.0.0 --port 80 --compressed-static

Jetez un oeil aux options de configuration.

Faire tourner 0bin en arrière plan¶

0bin ne vient pas avec un moyen intégré pour le faire. Il y a plusieurs solutions.

Pour un petit site:

Lancer simplement 0bin en processus shell d’arrière plan. Example sous GNU/Linux:

nohup python zerobin.py --host 0.0.0.0 --port 80 --compressed-static &

Ou dans un screen.

Pour les gros sites Web:

configurer 0bin et Apache;
configure 0bin avec supervisor (recommandé).

Note

Vous pouvez même utiliser zerobin sur votre réseau local depuis votre portable.

Assurez vous que votre parefeu ne bloque pas le port, et lancez:

python zerobin.py --host 0.0.0.0 --port 8000

0bin sera maintenant accessible sur http://votre.addresse.ip.locale:8000.

Ça peut être très un moyen très cool pour partager du code dans une entreprise ou a un code sprint.

Installation avec Apache¶

Note

Vous devez avoir suivi l’installation facile avant.

Apache est plus lourd que Nginx mais il est aussi beaucoup plus connu:

plus de gens pourront vous aider les fora;
votre hébergeur propose surement Apache;
la syntaxe des fichiers de configuration est familière pour beaucoup.

Une installation apache est aussi beaucoup plus solide et sécurisé qu’une installation facile. Vous bénéficierez:

de la possibilité d’avoir plusieurs projets écoutant sur le prot 80;
de plusieurs modules Apache à votre disposition (comme la limitation du nombre de requêtes);
de la solidité d’Apache en front end: il est sécurité, et il y a peu de chance qu’il crash sous une forte charge;
les processus de votre site ne tournent pas avec les droits admin, même si –user ne fonctionne pas sur votre OS.

Apache s’installe avec votre gestionnaire de paquet habituel, nous ne couvrierons pas cette partie.

Mod_wsgi¶

Les serveurs Web Python modernes fonctionnent tous de la même manière, en suivant une norme d’interfaçage: WSGI.

C’est la solution la plus performante, et celle recommandée. Mais elle demande l’installation du model Apache mod_wsgi. Si vous ne savez pas comment faire, ou si vous ne pouvez pas le faire (par example sur un hébergement mutualisé qui ne le propose pas), il vous faudra choisir l’installation CGI.

Premièrement, assurez-vous d’avoir mod_wsgi installé et chargé (en tant qu’admin):

a2enmod wsgi

Ceci va activer mod_wsgi. Si cela ne marche pas, il faudra l’installer d’abord ( sur ubuntu, le paquet est libapache2-mod-wsgi)

Ensuite, il faut créer un fichier de configuration Apache, généralement dans /etc/apache/sites-available/. Nommez le zerobin:

<VirtualHost *:80>
    ServerName www.votersiteweb.com

    WSGIDaemonProcess zerobin user=www-data group=www-data processes=1 threads=5
    WSGIScriptAlias / /chemin/vers/zerobin/app.wsgi

    <Directory /chemin/vers/zerobin/>
        WSGIProcessGroup zerobin
        WSGIApplicationGroup %{GLOBAL}
        Order deny,allow
        Allow from all
    </Directory>
</VirtualHost>

Activez le site web (en tant qu’admin):

a2ensite zerobin

Et rechargez la configuration d’Apache (en tant qu’admin):

service apache2 reload

Vous aurez noté que l’on fait référence à un fichier nommé app.wsgi. C’est un fichier Python qui créé l’application qu’Apache va utiliser pour lancer le processus Python:

import os, sys

# s'assurer que le module zerobin est dans le PYTHON PATH et importable
ZEROBIN_PARENT_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.insert(0, ZEROBIN_PARENT_DIR)

# créer le wsgi callable
from zerobin.routes import get_app
settings, application = get_app(compressed_static=True)

Vous pouvez bien sûr créer le votre, puisque la fonction get_app et le seul moyen de passer des paramètres à 0bin avec cette installation. Cela peut se faire en créant un fichier de configuration et en le passant à la fonction:

import os, sys

ZEROBIN_PARENT_DIR = '/chemin/du/dossier/parent/de/zerobin'
sys.path.insert(0, ZEROBIN_PARENT_DIR)

from zerobin.routes import get_app
settings, application = get_app(settings_file='/path/to/settings.py')

CGI¶

Vous pouvez aussi utiliser CGI, mais nous n’avons pas encore eu le temps de couvrir cette partie. Contactez nous si vous avez besoin de l’utiliser.

Installation avec Nginx¶

Note

Vous devez avoir suivi l’installation facile avant.

Nginx est un choix très populaire pour servir un projet Python:

Il est rapide.
Il est léger.
Les fichiers de configuration sont très simple.

Si vous avez votre propre serveur, c’est le meilleur choix. Dans le cas contraire, essayez l’installation la plus simple, ou avec Apache.

Nginx ne lance aucun processus Python, il sert uniquement les requêtes depuis l’extérieur vers le server Python.

Il y a donc deux étapes:

Faire tourner le processus Python.
Faire tourner Nginx.

Ainsi, vous bénéficierez:

de la possibilité d’avoir plusieurs projets écoutant sur le prot 80;
de plusieurs modules Nginx à votre disposition (comme la limitation du nombre de requêtes);
de la solidité de Nginx en front end: il est sécurité, et il y a peu de chance qu’il crash sous une forte charge;
les processus de votre site ne tournent pas avec les droits admin, même si –user ne fonctionne pas sur votre OS;
de la capacité de gérer un processus Python sans toucher Nginx ou les autres processus. C’est très pratique pour les mises à jour.

Processus Python¶

Lancez 0bin comme d’habitude, mais cette fois pour écouter sur un host et un port local. Ex

zerobin --host 127.0.0.1 --port 8000

En PHP, quand on édite un fichier, la modificiation est visible immédiatement. En Python, l’intégralité du code est chargé en mémoire pour des raisons de performance. Pour cette raison, il faut redémarrer le processus Python pour voir les changement prendre effet. Avoir un processus séparé permet de le faire sans avoir à redémarer le serveur.

Nginx¶

Nginx peut être installé avec votre gestionnaire de paquets habituels, donc nous ne couvrirons pas cette partie.

Vous devez créer une fichier de configuration Nginx pour 0bin. Sous GNU/Linux, on les mets en général dans /etc/nginx/conf.d/. Nommez le zerobin.conf.

Le fichier de configuration minimal pour faire tourner le site est:

server {
    listen       80;
    server_name www.votresiteweb.com;

    location / {
        proxy_pass http://127.0.0.1:8000;
    }
}

proxy_pass transmet les requêtes aux processus Python. Bien entendu le port doit correspondre à celui utilisé par 0bin.

On peut apporter plusieurs améliorations à l’expérience utilisateur:

server {
    listen       80;
    server_name www.votresiteweb.com;

    location /favicon.ico {
        root  /chemin/vers/zerobin/static/img;
    }

    location /static/ {
        root  /chemin/vers/zerobin;
        gzip  on;
        gzip_http_version 1.0;
        gzip_vary on;
        gzip_comp_level 6;
        gzip_proxied any;
        gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;
        gzip_buffers 16 8k;
        # Disable gzip for certain browsers.
        gzip_disable ~@~\MSIE [1-6].(?!.*SV1)~@~];
        expires modified +90d;
    }

    location / {
        proxy_pass http://zerobin_cherrypy;
    }
}

Nginx sert maintenant le favicon ainsi que les fichiers statiques, on a ajouté une date d’expiration dans les en-têtes HTTP et on s’assure que la compression gzip est utilisée pour les navigateurs qui la supporte.

Utiliser supervisor¶

Supervisor est un très bon moyen de gérer des processus Python. Nous n’allons pas couvrir son installation (qui la plupart du temps se résume à apt-get install supervisor ou pip install supervisor), mais voici un rapide résumé de comment l’utiliser:

Créez un fichier de configuration nommé supervisor.ini:

[unix_http_server]
file=/tmp/supervisor.sock;

[supervisorctl]
serverurl=unix:///tmp/supervisor.sock;

[rpcinterface:supervisor]
supervisor.rpcinterface_factory=supervisor.rpcinterface:make_main_rpcinterface

[supervisord]
logfile=/tmp/zerobin.log
logfile_maxbytes=50MB
logfile_backups=2
loglevel=trace
pidfile=/tmp/supervisord.pid
nodaemon=false
minfds=1024
minprocs=200
user=zerobin

[program:zerobin]
command=/chemin/vers/zerobin/zerobin.py --port 80 --compressed-static
directory=/chemin/vers/zerobin/
environment=PYTHONPATH='/chemin/vers/zerobin/'
user=zerobin
autostart=true
autorestart=true

Les 4 premières entrées sont juste de la configuration standard et vous pouvez les copier telles qu’elles.

La dernière entrée définie un processus (il peut y en avoir plusieurs) que supervisor doit gérer.

Cela veut dire qu’il va lancer la commande:

/chemin/vers/zerobin/zerobin.py --port 80 --compressed-static

Et ceci dans le dossier, avec l’environnement et l’utilisateur défini, le tout en arrière plan en tant que daemon.

autostart et autorestart permettent simplement de le lancer et de l’oublier: supervisor redémarera le processus automatiquement en cas d’arrêt impromptu.

La première fois que vous lancez supervisor, passez lui le fichier de configuration:

supervisord -c /chemin/vers/supervisor.ini

Ensuite vous pouvez gérer les processus avec:

supervisorctl -c /chemin/vers/supervisor.ini

Cela va démarrer un shell depuis lequel vous pouvez faire un start/stop/restart sur le service.

Toutes les erreurs seront logguées dans /tmp/zerobin.log.

Note

Si vous avez installé zerobin dans un virtualenv, vous devriez définir la commande pour qu’elle s’éxécute depuis le virtualenv:

command=/chemin/vers/le/virtualenv/bin/zerobin --port 80 --compressed-static

Personnaliser l’apparence¶

0bin possède un support de theming complet, mais pour le moment mal intégré.

Si vous souhaitez créer votre propre theme, il vous faut créer des templates similaires à ceux par défault présents dans zerobin/view, et ajouter le chemin du dossier contenant ces templates au fichier de configuration.

Vous aurez également besoin de copier les fichiers statiques présent dans zerobin/static dans un nouveau dossier, puis les modifier. Et signifiez que vous utilisez ce dossier dans le fichier de configuration.

Vous pouvez bien entendu également éditez tous les fichier directement par souci de simplicité.

Attention cependant, le code javascript est très dépendant des ID et classes du HTML, qui ne sont pour le moment pas très bien organisés.

Si vous avez de sérieux besoin de theming, contactez-nous, afin que nous améliorons le support.

Options¶

Le comportement de 0bin peut être ajusté à l’aide d’options passées depuis un fichier de configuration ou directement à la ligne de commande. Certains paramètres sont uniquement disponibles dans le fichier de configuration.

Si une option n’est pas passée, 0bin utilise la valeur par défaut présente dans le fichier zerobin/default_settings.py.

Ligne de commande¶

–host et –port¶

L’hôte et le port sur lesquels écouter les requêtes entrantes. En général 127.0.0.1 et 8000 pour écouter localement, ou 0.0.0.0 et 80 pour écouter les requêtes extérieures.

Défaut: 127.0.0.1 et 8000

Equivalent du fichier de configuration : HOST et PORT

–debug¶

Afffiche un listing d’informations utiles pour déboguer quand quelque chose se passe mal à la place d’une page d’erreur 500.

En mode debug, le serveur recharge aussi automatiquement tout fichier Python modifié.

Défaut: False

Equivalent du fichier de configuration : DEBUG

–user et –group¶

L’utilisateur et le group que le serveur essayera d’adopter après le démarrage.

Utile quand on lance la commande avec les droits admin afin de pouvoir écouter sur le port 80, mais qu’on souhaite, pour des raisons de sécurité, que le processus n’est pas accès aux fichiers protégés du système.

–group prend de –user si il n’est pas précisé.

Défaut: Aucun

Equivalent du fichier de configuration : USER et GROUP

–settings-file¶

Chemin vers le fichier de configuration, si vous souhaitez en utiliser un.

Défaut: Aucun

Equivalent du fichier de configuration : Aucun

–compressed-static¶

Sert les versions minifiées fichiers statiques (css et js). A utiliser en production pour un site plus rapide.

Défaut: False

Equivalent du fichier de configuration : COMPRESSED_STATIC_FILES

–version et –help¶

Affiche l’aide ou la version de 0bin

Défaut: Aucun

Equivalent du fichier de configuration : Aucun

Exemples¶

Production:

sudo zerobin --host 0.0.0.0 --port 80 --user foo --compressed-static

Développement:

zerobin --debug --serve-static

Fichier de configuration¶

Le fichier configuration doit être un fichier Python ordinnaire, généralement appelé settings.py. On l’utilise ainsi:

zerobin --settings-file '/chemin/vers/settings.py'

Toutes les autres options passées à la commandes auront priorité sur les options du fichier de configuration. Le fichier zerobin/default_settings.py peut servir d’exemple pour créer son propre fichier de configuration, il est largement commenté.

DEBUG¶

Afffiche un listing d’informations utiles pour déboguer quand quelque chose se passe mal à la place d’une page d’erreur 500.

En mode debug, le serveur recharge aussi automatiquement tout fichier Python modifié.

Défaut: False

Equivalent en ligne de commande : –debug

STATIC_FILES_ROOT¶

Chemin absolu du dossier dans lequel 0bin va chercher les fichiers statiques (css, js et images).

Défaut: dossier “static” dans le dossier “zerobin”

Equivalent en ligne de commande : Aucun

COMPRESSED_STATIC_FILES¶

Sert les versions minifiées fichiers statiques (css et js). A utiliser en production pour un site plus rapide.

Défaut: False

Equivalent en ligne de commande : –compressed-static

PASTE_FILES_ROOT¶

Chemin absolu du dossier dans lequel 0bin va sauvegarder les pastes.

Défaut: dossier “static/content” dans le dossier “zerobin”

Equivalent en ligne de commande : Aucun

TEMPLATE_DIRS¶

Liste des chemins absolus des dossiers qui contiennent les templates que 0bin utilise pour générer les pages du site. Les premiers éléments de la liste ont priorités sur les suivant.

Si vous voulez utiliser vos propres templates, ajoutez le dossier qui les contient au début de la liste:

from zerobin.defauls_settings import TEMPLATE_DIRS

TEMPLATE_DIRS = (
    '/chemin/version/votre/dossier/de/templates',
) + TEMPLATE_DIRS

Défaut: dossier “view” dans le dossier “zerobin”

Equivalent en ligne de commande : Aucun

HOST et PORT¶

L’hôte et le port sur lesquels écouter les requêtes entrantes. En général 127.0.0.1 et 8000 pour écouter localement, ou 0.0.0.0 et 80 pour écouter les requêtes extérieures.

Défaut: 127.0.0.1 et 8000

Equivalent du fichier de configuration : –host et –port

USER et GROUP¶

L’utilisateur et le group que le serveur essayera d’adopter après le démarrage.

Utile quand on lance la commande avec les droits admin afin de pouvoir écouter sur le port 80, mais qu’on souhaite, pour des raisons de sécurité, que le processus n’est pas accès au fichiers système.

GROUP prend de USER si il n’est pas précisé.

Défaut: Aucun

Equivalent en ligne de commande : –user et –group

MAX_SIZE¶

Valeur approximative de limite de taille d’un paste.

Défaut = 500000 octets (500 ko)

Equivalent en ligne de commande : Aucun

Outil en ligne de commande zerobinpaste¶

zerobinpaste est un simple outil CLI (similaire à pastebinit ou wgetpaste) à utiliser avec des fichiers ou des redirection shell dans le terminal ou des scripts simples.

Exemple de cas d’utilisation:

% zerobinpaste README.rst
http://some.0bin.site/paste/0cc3d8a8...

% grep error /var/log/syslog | zerobinpaste
http://some.0bin.site/paste/81fd1324...

% zerobinpaste docs/en/*.rst
easy_install.rst http://some.0bin.site/paste/9adc576a...
apache_install.rst http://some.0bin.site/paste/01408cbd...
options.rst http://some.0bin.site/paste/921b2768...
...

% ps axlf | zerobinpaste | mail -s "Process tree on $(date)" root

Les liens produits peuvent être ensuite copier-coller sur un channel IRC ou autre.

L’outil produit le chiffrement lui-même sur la machine et la clé (après le hash) n’est jamais envoyée au serveur ou nul par ailleurs excepté la sortie standard de l’outil (ex: le terminal).

L’outil doit être buildé avec node.js séparément (voir plus bas).

Usage¶

Au minimum il faut préciser le site pastebin (l’url principal d’où on posterait dans le navigateur) doit être spécifié à l’outil via l’option -u (–url) (on peut le simplifier avec un alias shell - ex: alias zp='zerobinpaste -u http://some.0bin.site) ou dans le fichier de configuration “~/.zerobinpasterc” (format json).

Les arguments positionels sont interprétés comme des fichiers à uploader et chiffrer.

Si aucun argument n’est passé, le script tentera de lire stdin.

Le fichier de configuration le plus simple pourrait ressembler à celà:

{“url”: “http://some.0bin.site“}

Toute option (dans sa forme longue, ex: “url pour –url) utilisable en ligne de commande peut être spécifié ici.

Lancez l’outil avec -h ou –help pour voir la liste des paramètres supportés.

Build / Installation¶

En bref:

0bin% cd tools 0bin/tools% make ... 0bin/tools% cp zerobinpaste ~/bin # install to PATH

La commande “npm” (packagé and installé avec node.js) est requise pour télécharger les dépendances indispensables à la production de l’éxécutable.

Utilisez “make” dans le dossier “tools” pour produire une version non-minifié” de “zerobinpaste”.

La commande make ugly peut être utilisé à la place de make pour créer une version “minified” (requière l’installation de uglifyjs, script produit environ 25% plus petit en taille).

Le script “zerobinpaste” ainsi produit seulement besoin de node.js (et la commande “node”) pour s’éxcuter et peut être placé n’importe où dans le PATH système (ex : “~/bin”, “/usr/local/bin”) afin d’être exécuté en tapant simplement “zerobinpaste”.

Pourquoi node.js et pas python¶

Malheureusement, il est assez difficile et peu fiable de répliquer un protocole chiffrement non trivial et non documenté tel que celui de certaines méthodes de SJCL, et la moindre erreur garantie de produire une paste illisible.

L’implémentation actuelle utilise le même code Javascript (via le moteur V8 de node.js) que le navigateur, du coup il est simple et robuste.

Il est prévu de supporter plus tard un schéma de chiffrement plus configurable, moins complexe et plus courant, permettant à des clients non-javascript de fonctioner également.

Voir le pull request concerné pour plus de détails.

Signaler un bug

0bin’s documentation¶

Introduction¶

How it works¶

Other features¶

Technologies used¶

Known issues¶

What does 0bin not implement?¶

Easiest installation¶

10 seconds setup (if you know Python already)¶

30 seconds setup (for anybody)¶

Run 0bin in background¶

Apache setup¶

Mod_wsgi¶

CGI¶

Nginx setup¶

The Python process¶

Nginx¶

Using supervisor¶

Theming¶

Options¶

Command line¶

–host and –port¶

–debug¶

–user and –group¶

–settings-file¶

–compressed-static¶

–version and –help¶

Examples¶

Configuration file¶

DEBUG¶

STATIC_FILES_ROOT¶

COMPRESSED_STATIC_FILES¶

PASTE_FILES_ROOT¶

TEMPLATE_DIRS¶

HOST and PORT¶

USER and GROUP¶

MENU¶

MAX_SIZE¶

zerobinpaste command-line tool¶

Usage¶

Build / Installation¶

Why node.js and not python¶

Introduction¶

Comment ça marche¶

Autres fonctionalités¶

Technologies utilisées¶

Problèmes connus¶

Qu’est-ce que 0bin ne fait pas ?¶

Installation la plus simple¶

Installation en 10 secondes (si vous connaissez Python)¶

Installation en 30 secondes (pour tous)¶

Faire tourner 0bin en arrière plan¶

Installation avec Apache¶

Mod_wsgi¶

CGI¶

Installation avec Nginx¶

Processus Python¶

Nginx¶

Utiliser supervisor¶

Personnaliser l’apparence¶

Options¶

Ligne de commande¶

–host et –port¶

–debug¶

–user et –group¶

–settings-file¶

–compressed-static¶

–version et –help¶

Exemples¶

Fichier de configuration¶

DEBUG¶

STATIC_FILES_ROOT¶

COMPRESSED_STATIC_FILES¶

PASTE_FILES_ROOT¶

TEMPLATE_DIRS¶

HOST et PORT¶

USER et GROUP¶

MENU¶

MAX_SIZE¶

Outil en ligne de commande zerobinpaste¶