beaglebone

letsencrypt Zertifikat auf Beagle Bone Black verlängern

Was vor drei Monaten geschah

Das Zertifikat ist abgelaufen und muss jetzt erneuert werden.

Auf der virtuellen Maschine Kubuntu

$ cd letsencrypt/
$ ./letsencrypt-auto --rsa-key-size 4096 --manual certonly

Eingeben der Domain-Namen

bone.nfix.de

auf dem Beaglebone ins Grundverzeichnis www wechseln und die von letsencrypt erwartete Datei anlegen

$ sudo -i
# cd /var/www/
# printf "%s" KENNUNGS-STRING > .well-known/acme-challenge/KENNUNGS-DATEI

Auf der virtuellen Maschine

  • Enter,
  • Gratulation
  • Your cert will expire on 2016–06–07.
  • Die erzeugten Schlüssel auf den Beaglebone in das Verzeichnis Schlüssel kopieren
$ sudo -i
# cd /etc/letsencrypt/archive/bone.nfix.de/
# scp * wnf@bone2013:schluessel
cert1.pem                                                  100% 2134     2.1KB/s   00:00
cert2.pem                                                  100% 2134     2.1KB/s   00:00
chain1.pem                                                 100% 1675     1.6KB/s   00:00
chain2.pem                                                 100% 1675     1.6KB/s   00:00
fullchain1.pem                                             100% 3809     3.7KB/s   00:00
fullchain2.pem                                             100% 3809     3.7KB/s   00:00
privkey1.pem                                               100% 3272     3.2KB/s   00:00
privkey2.pem                                               100% 3276     3.2KB/s   00:00

Auf dem Beaglevone Den Http-Server anhalten:

$ sudo -i
# service lighttpd stop
# cd /home/wnf/schluessel
# cat privkey2.pem cert2.pem > ssl.pem
# cd /etc/letsencrypt/live/
# cp /home/wnf/schluessel/ssl.pem .
# cp /home/wnf/schluessel/fullchain2.pem ./fullchain.pem

Den Http-Server wieder starten:

# service lighttpd start

Und schon hat der Beaglebone wieder ein gültiges Zertifikat: https://bone.nfix.de/

Auf dem Beaglebone den lighttp-Server für https konfigurieren

Literatur

Voraussetzung

In der VM eine dhparam.pem erstellen (dauert auf dem BBB zu lange)

$ openssl dhparam -out dhparam.pem 4096

die Dateien auf den Beaglebone kopieren

# scp dhparam.pem wnf@bone2013:schluessel
$ sudo -i
# service lighttpd stop

SSL für lighttpd auf dem Beaglebone einrichten

# cd /home/wnf/schluessel
# cat privkey1.pem cert1.pem > ssl.pem
# mkdir /etc/letsencrypt/live/
# cd /etc/letsencrypt/live/
# cp /home/wnf/schluessel/ssl.pem .
# cp /home/wnf/schluessel/fullchain1.pem ./fullchain.pem
# cd /etc/ssl/certs/
# cp /home/wnf/schluessel/dhparam.pem .
# cd /etc/lighttpd/conf-enabled
# touch letsencrypt.conf
# nano letsencrypt.conf
$SERVER["socket"] == ":443" {
     ssl.engine                  = "enable"
     ssl.pemfile                 = "/etc/letsencrypt/live/ssl.pem"
     ssl.ca-file                 =  "/etc/letsencrypt/live/fullchain.pem"
     ssl.dh-file = "/etc/ssl/certs/dhparam.pem"
     ssl.ec-curve = "secp384r1"
     ssl.honor-cipher-order = "enable"
     ssl.cipher-list = "EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH"
     ssl.use-compression = "disable"
     setenv.add-response-header = (
    "Strict-Transport-Security" => "max-age=63072000; includeSubdomains; preload",
    "X-Frame-Options" => "DENY",
    "X-Content-Type-Options" => "nosniff"
)
ssl.use-sslv2 = "disable"
ssl.use-sslv3 = "disable"
}

Beaglebone Black mit Ubuntu als SVN-Server einrichten

Das SVN-Verzeichnis möchte ich auf einem USB-Stick am Beaglebone anlegen.

Jedoch war der USB-Stick nach dem Einstecken nicht sichtbar.

Make sure the usb device is plugged in before power on.. USB hotplug is not working

Also den Beaglebone nach 200 Tagen Uptime neu starten. Ein bisschen weh hat das schon getan.

Jetzt benutze ich doch eine 16GB-Micro-SDCard

Linux-Partition erstellen

$ sudo fdisk /dev/mmcblk0
Command (m for help): p

Disk /dev/mmcblk0: 30.9 GB, 30908350464 bytes
255 heads, 63 sectors/track, 3757 cylinders, total 60367872 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00000000

        Device Boot      Start         End      Blocks   Id  System
/dev/mmcblk0p1            8192    60367871    30179840    c  W95 FAT32 (LBA)

Command (m for help): d
Selected partition 1

Command (m for help): p

Disk /dev/mmcblk0: 30.9 GB, 30908350464 bytes
255 heads, 63 sectors/track, 3757 cylinders, total 60367872 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00000000

        Device Boot      Start         End      Blocks   Id  System

Command (m for help): n
Partition type:
   p   primary (0 primary, 0 extended, 4 free)
   e   extended
Select (default p): p
Partition number (1-4, default 1): 1
First sector (2048-60367871, default 2048):
Using default value 2048
Last sector, +sectors or +size{K,M,G} (2048-60367871, default 60367871):
Using default value 60367871

Command (m for help): p

Disk /dev/mmcblk0: 30.9 GB, 30908350464 bytes
255 heads, 63 sectors/track, 3757 cylinders, total 60367872 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00000000

        Device Boot      Start         End      Blocks   Id  System
/dev/mmcblk0p1            2048    60367871    30182912   83  Linux

Command (m for help): w
The partition table has been altered!

Calling ioctl() to re-read partition table.
Syncing disks.

ext 4 Filesystem erstellen

$ sudo mkfs.ext4 /dev/mmcblk0p1

Mountpunkt erstellen

$ sudo mkdir /var/svn

BlkID anzeigen und kopieren

$ sudo blkid
[sudo] password for wnf:
/dev/mmcblk0p1: UUID="a7735e75-307b-4223-8d28-9e454136fdd9" TYPE="ext4"
/dev/mmcblk1p1: LABEL="rootfs" UUID="235d14e8-cf33-4c0e-ad4a-feeb81e0fe17" TYPE="ext4"

In die FSTAb eintragen

$ sudo nano /etc/fstab
UUID=a7735e75-307b-4223-8d28-9e454136fdd9 /var/svn/ ext4 noatime,errors=remount-ro  0  1

Mounten

$ sudo mount /var/svn
$ df -h
Filesystem      Size  Used Avail Use% Mounted on
/dev/mmcblk1p1  1.8G  837M  842M  50% /
none            4.0K     0  4.0K   0% /sys/fs/cgroup
udev            247M   12K  247M   1% /dev
tmpfs            50M  256K   50M   1% /run
none            5.0M     0  5.0M   0% /run/lock
none            249M     0  249M   0% /run/shm
none            100M     0  100M   0% /run/user
/dev/mmcblk0p1   29G   44M   27G   1% /var/svn

Cherrypy auf Beaglebone

Der Beaglebone ist wieder im Netz zu erreichen: http://bone.nfix.de


Erst Cherrypy3 hat das Attribut quickstart

attributeerror ‚module‘ object has no attribute ‚quickstart‘

$ sudo apt-get install python-cherrypy3

unsupported locale setting

$ locale -a
C
C.UTF-8
POSIX
en_AG
en_AG.utf8
en_AU.utf8
en_BW.utf8
en_CA.utf8
en_DK.utf8
en_GB.utf8
en_HK.utf8
en_IE.utf8
en_IN
en_IN.utf8
en_NG
en_NG.utf8
en_NZ.utf8
en_PH.utf8
en_SG.utf8
en_US.utf8
en_ZA.utf8
en_ZM
en_ZM.utf8
en_ZW.utf8
$ sudo apt-get install language-pack-de

ssh auf Beaglebone erneut freischalten

Da mein Beaglebone Black wegen einer fehlerhaften SD-Karte neu aufgesetzt werden musste, muss zuerst der alte Fingerprint entfernt werden.

$ ssh-keygen -f "/home/wnf/.ssh/known_hosts" -R bone2013

Danach wird der Publickey an den Beaglebone gesendet:

$ ssh-copy-id -i ~/.ssh/id_rsa.pub wnf@bone2013

und schon kann ich mich wieder ohne Eingabe eines Passworts auf dem Beaglebone einloggen.

wnf@c2012:~$ ssh wnf@bone2013
Welcome to Ubuntu 14.04.1 LTS (GNU/Linux 3.8.13-bone70 armv7l)
Last login: Tue Feb 10 16:47:23 2015 from c2012.fritz.box
wnf@bone2013:~$

Auf Beaglebone Black Ubuntu installieren

Die genaue Vorgehensweise ist bei elinux.org beschrieben.

Benötigte Pakete

  • git
  • wget
  • dosfstools
  • u-boot-tools
  • parted
$ sudo apt-get install git wget dosfstools u-boot-tools parted

Die SD-Karte für den Beaglebone in den Rechner stecken. Die SD-Karte darf nicht gemounted werden.

kontrollieren, wie die SD-Karte erkannt wird

$ ls -l /dev/sd[TAB][TAB]

Es wird das neue Device sdc angezeigt.

$ cd /tmp

Holen der Installationsda­teien mit Hilfe von git

$ git clone https://github.com/RobertCNelson/netinstall.git

Das System auf die SD-Karte installieren.

$ sudo ./mk_mmc.sh --mmc /dev/sdc --dtb am335x-boneblack --distro trusty --firmware --serial-mode

Die SD-Karte aus dem Rechner entfernen und im Beaglebone einlegen. Den Beaglebone per USB am Rechner anschließen . Die Verbindung über minicom herstellen.

$ sudo minicom -D /dev/ttyUSB0

Die Reset-Taste des Beaglebone drücken (rechts außen neben dem Netzwerkstecker.)

Tags: 

bbb lighttpd und python

Zum nachlesen

Kochbuch

$ sudo apt-get install lighttpd
  • diverse Änderungen in /etc/lighttpd/lig­httpd.conf
$ sudo nano /etc/lighttpd/lighttpd.conf
  • mod_cgi hinzufügen
server.modules = (
        "mod_access",
        "mod_alias",
        "mod_compress",
        "mod_redirect",
#       "mod_rewrite",
        "mod_cgi",
)
  • Python dem cgi-Modul zur Verfügung stellen
cgi.assign = ( ".py" => "/usr/bin/python" )
static-file.exclude-extensions = ( ".php", ".pl", ".fcgi", ".py" )
  • Das Verzeichnis /var/www/cgi-bin anlegen
$ sudo mkdir /var/www/cgi-bin
$ sudo /etc/init.d/lighttpd restart
  • In diesem Verzeichnis dieses Python Script ablegen (mit freundlicher Unterstützung von planzero.org
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#http://planzero.org/blog/2012/01/26/system_uptime_in_python,_a_better_way

from datetime import timedelta

print "Content-Type: text/html"
print
print "<title>Uptime des Beaglebone Black</title>"
print "<h1>Uptime des Beaglebone Black</h1>"

with open('/proc/uptime', 'r') as f:
    uptime_seconds = float(f.readline().split()[0])
    uptime_string = str(timedelta(seconds = uptime_seconds))

print(uptime_string)

Testaufruf mit http://bone.nfix.de/…wnfuptime.py

beaglebone black bbb und seafile

Nach dieser Anleitung habe ich den seafile-server auf meinem Weihnachtsgeschenk installiert

$ sudo su
# useradd -r seafile
# cd /opt
# mkdir seafile
# cd /opt/seafile
# wget http://seafile.googlecode.com/files/seafile-server_2.0.3_pi.tar.gz
# tar -xvf seafile-server_2.0.3_pi.tar.gz
# rm seafile-server_2.0.3_pi.tar.gz
# mv seafile-server-2.0.3 seafile-server
# cd seafile-server/
# ./setup-seafile.sh
# mkdir /opt/seafile/logs
# chown seafile:seafile -R /opt/seafile/
# chown seafile:seafile -R /var/seafile-data/

Seafile Server

This is your config information:

server name:        bone2013
server ip/domain:   bone.nfix.de
server port:        10001
seafile data dir:   /var/seafile-data
seafile port:       12001
httpserver port:    8082

Seahub

Seahub is the web interface for seafile server.

-----------------------------------------------------------------
Your seafile server configuration has been finished successfully.
-----------------------------------------------------------------

run seafile server:     ./seafile.sh { start | stop | restart }
run seahub  server:     ./seahub.sh  { start <port> | stop | restart <port> }

-----------------------------------------------------------------
If you are behind a firewall, remember to allow input/output of these tcp ports:
-----------------------------------------------------------------

port of ccnet server:         10001
port of seafile server:       12001
port of seafile httpserver:   8082
port of seahub:               8000

When problems occur, Refer to https://github.com/…seafile/wiki for information.

Den server beim Booten starten

# nano /etc/init.d/seafile-server
#!/bin/sh

# Change the value of "user" to your linux user name
user=seafile

# Change the value of "script_path" to your path of seafile installation
seafile_dir=/opt/seafile
script_path=${seafile_dir}/seafile-server-2.0.4
seafile_init_log=${seafile_dir}/logs/seafile.init.log
seahub_init_log=${seafile_dir}/logs/seahub.init.log

# Change the value of fastcgi to true if fastcgi is to be used
fastcgi=false
# Set the port of fastcgi, default is 8000. Change it if you need different.
fastcgi_port=8000

case "$1" in
        start)
                sudo -u ${user} ${script_path}/seafile.sh start > ${seafile_init_log}
                if [  $fastcgi = true ];
                then
                        sudo -u ${user} ${script_path}/seahub.sh start-fastcgi ${fastcgi_port} > ${seahub_init_log}
                else
                        sudo -u ${user} ${script_path}/seahub.sh start > ${seahub_init_log}
                fi
        ;;
        restart)
                sudo -u ${user} ${script_path}/seafile.sh restart > ${seafile_init_log}
                if [  $fastcgi = true ];
                then
                        sudo -u ${user} ${script_path}/seahub.sh restart-fastcgi ${fastcgi_port} > ${seahub_init_log}
                else
                        sudo -u ${user} ${script_path}/seahub.sh restart > ${seahub_init_log}
                fi
        ;;
        stop)
                sudo -u ${user} ${script_path}/seafile.sh $1 > ${seafile_init_log}
                sudo -u ${user} ${script_path}/seahub.sh $1 > ${seahub_init_log}
        ;;
        *)
                echo "Usage: /etc/init.d/seafile {start|stop|restart}"
                exit 1
        ;;
esac
# /etc/init.d/seafile-server start
Tags: