Artikel Debian

Beitrag von **dvajda** » Mo Nov 20, 2023 10:13 pm

Pakete bauen und - Ein Repository machen.

So weit ist der Stand bis heute

Also, mit
Code: Alles auswählen
```
gcc
```
kann ich gut umgehen, also ich kann C programmieren, das ist ein anderes Thema
Jetzt habe ich schon lange Debian - und was mir bis vor kurzem gefehlt hat - war. Ich konnte schon mit
Code: Alles auswählen
```
apt-get 
```
umgehen. Aber ich wusste nicht sehr genau über die
Code: Alles auswählen
```
/etc/apt/sources.list
```
Bescheid. Ich habe den Inhalt mehr oder weniger von
https://wiki.ubuntuusers.de/
Das ist aber kein Privatding von denen. Ich werde gleich posten, was ich gelernt habe. Und sage, das ist aber grössten teils von denen. Das können sie da nachlesen. Ich habe aber eine Sammlung gemacht.
Dazu gehört auch
Code: Alles auswählen
```
gpg
```
. Das ist einfach zu benutzen
Aber, was mich jetzt interessierte war, ob ich einfach eigene Pakete für Debian erstellen kann
Die zweite Frage, wenn ich die Pakete erstellt habe, kann ich ein eigenes Repository machen
Dazu sei gesagt, es ist mir gelungen Pakete zu machen - ich habe es mit
Code: Alles auswählen
```
hello world
```
. Ich weiss noch nicht, wie das mit Repository ist, aber das wird wohl gehen und muss nur auf einem Webserver ein Verzeichnis so zu sagen sein
Ich würde zum Beispiel die übungsprogramme anbieten, so wie irgendwelche kleinen Compiler
Das mit dem Paketbau ist sehr simpel - es ist mir gelungen - nur
Code: Alles auswählen
```
DESTDIR
```
konnte ich nicht bisher hinkriegen. Ich muss morgen früh weg. Und jetzt ist erst Mal Pause
die Idee, zum Paketbau finden sie hier:
https://wiki.ubuntuusers.de/Grundlagen_ ... rstellung/

Und ich beschreibe das jetzt aus meiner Sicht.

Das erste, was ich jetzt genauer gelernt habe, ist das da:


Die nächste Veröffentlichung von Debian heißt "trixie" – "Testing", bisher noch kein Veröffentlichungsdatum
Debian 12 ("Bookworm") – aktuelle Veröffentlichung - "Stable"
Debian 11 ("Bullseye") – aktuelle Veröffentlichung - "Oldstable"
Debian 10 ("Buster") – aktuelle Veröffentlichung - "Oldoldstable" unter LTS-Support
Debian 9 ("Stretch") – veraltete Veröffentlichung, unter erweitertem LTS-Support
Debian 8 ("Jessie") – veraltete Veröffentlichung, unter erweitertem LTS-Support
Debian 7 ("Wheezy") – veraltete Veröffentlichung
Debian 6.0 ("Squeeze") – veraltete Veröffentlichung
Debian GNU/Linux 5.0 ("Lenny") – veraltete Veröffentlichung
Debian GNU/Linux 4.0 ("Etch") – veraltete Veröffentlichung
Debian GNU/Linux 3.1 ("Sarge") – veraltete Veröffentlichung
Debian GNU/Linux 3.0 ("Woody") – veraltete Veröffentlichung
Debian GNU/Linux 2.2 ("Potato") – veraltete Veröffentlichung
Debian GNU/Linux 2.1 ("Slink") – veraltete Veröffentlichung
Debian GNU/Linux 2.0 ("Hamm") – veraltete Veröffentlichung

Stable
Testing
Unstable

Architectures:
64-bit PC (amd64)
64-bit ARM (AArch64)
EABI ARM (armel)
Hard Float ABI ARM (armhf)
32-bit PC (i386)
MIPS (little endian)
64-bit MIPS (little endian)
POWER Processors
IBM System z

deb cdrom:[Debian GNU/Linux 12.2.0 _Bookworm_ - Official amd64 NETINST with firmware 20231007-10:28]/ bookworm main non-free-firmware
deb http://deb.debian.org/debian/ bookworm main non-free-firmware
deb-src http://deb.debian.org/debian/ bookworm main non-free-firmware
deb http://security.debian.org/debian-security bookworm-security main non-free-firmware
deb-src http://security.debian.org/debian-security bookworm-security main non-free-firmware

http://deb.debian.org/
http://deb.debian.org/debian/
deb-src http://security.debian.org
deb-src http://security.debian.org/debian-security

bookworm
bookworm-backports
bookworm-security

main
non-free-firmware
contrib
non-free


/etc/apt/sources.list
/etc/apt/sources.list.d/

deb http://de.archive.ubuntu.com/ubuntu jammy main restricted

"Typ": deb oder deb-src
"Ort": z.B. http://de.archive.ubuntu.com/ubuntu (oder auch eine CD/DVD)
"Distribution": jammy, jammy-updates, jammy-security, usw.
"Komponenten" (optionale Liste): main, restricted, universe, multiverse

Typ: deb deb-src
Ort: cdrom http ftp file copy

lsb_release -cir
cp /etc/apt/sources.list /etc/apt/sources.list.bak
cat -n /etc/apt/sources.list
apt-get update

Multiarch
PPA: Personal Package Archive
apt: Advanced Package Tool
Paketstatus
Backport: Rückportierung

dpkg-dev
apt-get install dpkg-dev

apt
apt-get
dpkg
dpkg-query
dpkg-deb
dpkg-repack


apt [OPTIONEN] BEFEHL

update
upgrade
full-upgrade
install PAKETNAME
install /PFAD/ZUM/PAKET
reinstall PAKETNAME
remove PAKETNAME
purge PAKETNAME
autoremove
search SUCHBEGRIFF
show PAKETNAME
list SUCHMUSTER
edit-sources

apt install foo_1.0_all.deb      # falsch
apt install ./foo_1.0_all.deb

apt-get [OPTIONEN] KOMMANDO [PAKET1] [PAKET2]

update
upgrade
install PAKET(E)
remove PAKET(E)
autoremove [PAKET(E)]
purge PAKET(E)
source PAKET(E)
build-dep PAKET(E)
dist-upgrade
dselect-upgrade
clean
autoclean
check    	Überprüfung auf Abhängigkeitsfehler
markauto PAKET(E) 	PAKET(E) als "automatisch installiert" markieren
unmarkauto PAKET(E) 	PAKET(E) als "manuell installiert" markieren
changelog PAKET(E)
download PAKET(E) 	PAKET(E) herunterladen

Optionen

--fix-broken
--fix-missing, --ignore-missing
 --install-suggests
 ...

dpkg
-i 	--install
	--configure
-r 	--remove
-l 	--list
-P 	--purge
-R 	--recursive
-L 	--listfiles
-S 	--search

dpkg-query
-l 	--list
-S 	--search
-L 	--listfiles

Paketstatus
u für unbekannt
i für installieren
h für halten
r für entfernen (Konfigurationsdateien behalten)
p für vollständig (inkl. Konfigurationsdateien) entfernen

dpkg-deb

dpkg-deb stellt grundlegende Möglichkeiten zum Packen und Entpacken, sowie die Abfrage von Metainformationen
-I 	--info
-b 	--build
-c 	--contents
-x 	--extract

dpkg-repack

Schlüsselverwaltung: Pakete in Paketquellen werden mit einem Schlüssel kryptografisch signiert

apt/apt-key
/etc/apt/trusted.gpg
/etc/apt/trusted.gpg.d/
/etc/apt/keyrings/schluessel.gpg

gpg

sudo wget -nc -O /etc/apt/keyrings/example-archive-keyring.gpg https://example.org/public.key
curl https://example.org/public-key.asc | sudo -H gpg --dearmor -o /etc/apt/keyrings/example-archive-keyring.gpg

Schlüssel hinzufügen
ASCII-verpackte Schlüssel (base64-kodiert)
sie dekodieren (dearmor)
OpenPGP-Binärdatei
signed-by

Anhand der Schlüssel-ID kann ebenfalls ein Schlüssel hinzugefügt werden
sudo -H gpg -k && sudo -H gpg --no-default-keyring --keyring /usr/share/keyrings/schlüssel.gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys <Schlüssel-ID>

sources.list anpassen

deb [signed-by=/etc/apt/keyrings/schluessel.gpg] http://example.org/linux/deb/ stable main

/etc/apt/sources.list
/etc/apt/sources.list.d/datei.list



GNU Privacy Guard (GnuPG)
Schlüsselpaar
asymmetrischen Verschlüsselung

symmetrischen Verfahren: Viele Verschlüsselungsformen nutzen sowohl für die Verschlüsselung als auch für die Entschlüsselung den gleichen Schlüssel

assymetrisch: Man gibt den Absperrschlüssel an seine Kommunikationspartner  weiter

privaten Schlüssel.
öffentlichen Schlüssel

Symmetrisch
Assymmetrisch
Hybride Verfahren

GnuPG verwendet ein hybrides Verfahren zur Verschlüsselung.
asymmetrische Verschlüsselung extrem rechenintensiv ist
weigentliche Nachricht tatsächlich symmetrisch verschlüsselt.
Hierfür wird intern ein "Einweg-Schlüssel" erzeugt.

Mit diesem Schlüssel wird zunächst die Nachricht verschlüsselt, was nun wesentlich schneller geht.
Es wird nur der relativ kurze, symmetrische Schlüssel mit dem asymmetrischen Schlüssel (öffentlicher Schlüssel) gesichert.
Der jetzt gesicherte symmetrische Schlüssel wird sodann zusammen mit der gesicherten Nachricht versandt.
Der Empfänger nutzt seinen privaten Schlüssel, um Zugang zum geheimen, symmetrischen Schlüssel zu erlangen, und kann damit schließlich die Nachricht wiederherstellen

sichere und geheime Kanäle
Man-in-the-middle-Angriff

Nachdem A den öffentlichen Schlüssel von B - wie auch immer - bekommen hat, muss sich A die Authentizität des Schlüssels bestätigen lassen

Jeder Schlüssel hat eine Art Fingerabdruck, eine unverwechselbare Kennung.
sicherer Kanal
Passwortsätze

gnupg

Der Schlüsselbund
 ~/.gnupg/.

GnuPG speichert alle Schlüssel, die man mit der Zeit sammelt, in einem "Schlüsselbund" im Verzeichnis ~/.gnupg/.

Schlüssel auflisten
gpg --list-secret-keys
gpg -K

gpg --list-keys
gpg -k

Key-ID
sec  1024D/ABCD1234 2005-06-18 Max Mustermann <max.m _at_ example.com>

Fingerprint
Ein Fingerprint (dt.: Fingerabdruck) ist ein relativ kurzer Hash-Wert, mit dem man Schlüssel verifizieren kann
. Dieser identifiziert einen Schlüssel, so wie der menschliche Fingerabdruck einen Menschen (praktisch) eindeutig identifizier

gpg --fingerprint <ID oder Name des Schlüssels>

Schlüsselpaar erzeugen
gpg --full-gen-key

Bitte wählen Sie, welche Art von Schlüssel Sie möchten:
   (1) RSA und RSA (voreingestellt)
   (2) DSA und Elgamal
   (3) DSA (nur unterschreiben/beglaubigen)
   (4) RSA (nur signieren/beglaubigen)
Ihre Auswahl?

ECC Schlüssel¶
gpg --expert --full-gen-key

Schlüssel importieren¶
Erhält man den öffentlichen Schlüssel eines Kommunikationspartners oder will man ein Schlüsselpaar (also einen privaten und einen öffentlichen Schlüssel) importieren, so muss man ihn zur weiteren Verwendung zunächst in den Schlüsselbund importieren.

gpg --with-fingerprint /tmp/dateiname.asc
gpg --import /tmp/dateiname.asc


GnuPG

Schlüssel importieren

Erhält man den öffentlichen Schlüssel eines Kommunikationspartners oder will man ein Schlüsselpaar (also einen privaten und einen öffentlichen Schlüssel) importieren, so muss man ihn zur weiteren Verwendung zunächst in den Schlüsselbund importieren.

Man sollte aber auf keinen Fall Schlüssel ungeprüft verwenden! Entweder man nimmt persönlichen Kontakt zum Kommunikationspartner auf und gleicht den "fingerprint" ab, oder man nutzt das GnuPG/Web of Trust.

gpg --with-fingerprint /tmp/dateiname.asc

gpg --import /tmp/dateiname.asc

⚓︎


Schlüssel exportieren

Ebenso kann man einen Schlüssel exportieren. Das ist z.B. notwendig, wenn man seinen öffentlichen Schlüssel auf seiner Webseite zum freien Herunterladen anbieten will,

gpg -a --output gpg-key --export <Schlüssel-ID oder Name>
gpg -a --export <Schlüssel-ID oder Name> | tee gpg-key

Verschlüsseln

gpg --encrypt -a --recipient <Name oder Key_Id> test.txt

Entschlüsseln

gpg --decrypt --output entschluesselt.txt test.txt.asc

Signieren

gpg --detach-sig -a test.txt

Nachdem man seine Passphrase erfolgreich eingegeben hat, erhält man eine Datei test.txt.asc. Diese enthält eine digitale Signatur der Originaldatei mit der sich die Authentizität beweisen lässt. Hier ein Beispiel:

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.1 (GNU/Linux)
iD8DBQFDTqEJxHY64NcyylkRAvZ2AJoDxlQ4VuqpIDfcTFnHEye4PGfNIACdEcRw
QVoj5npyj4VyaEzLzx4vdSs=
=ySv1
-----END PGP SIGNATURE---

gpg --verify test.txt.asc

gpg: Signature made Mon 19 Jun 2006 17:06:05 CEST using DSA key ID <Key_Id>
gpg: Good signature from "Person, von der die Signatur stammt"

adele@gnupp.de

Das tut so weit - ansonsten konnte ich mit

Code: Alles auswählen

apt-get

natürlich umgehen. Ich kann ja mein Debian verwalten. aber so gut nicht. Wie genau man es machen könnte

Gut, jetzt geht es darum, Pakete zu bauen

Lange Unterlassungssünde - ich denke, das ist nicht schwer nach zu holen. Ich habe beim Thema
Code: Alles auswählen
```
make
```
Nachholbedarf
Das einfachste
Code: Alles auswählen
```
Makefile
```
sieht so aus
Code: Alles auswählen
```
hello: hello.c
	gcc -o hello hello.c
```
und damit geht es.
Man legt nun einen Ordner an
Code: Alles auswählen
```
/home/david/davidhello
```
Und geht da rein. Dann macht man eine C-Datei -
Code: Alles auswählen
```
hello.c
```
und schreibt rein:
Code: Alles auswählen
```
#include <stdio.h>

int main (void) {
	printf ("Hallo Welt\n");
return 0;
}
```
Gut dann man ein Verzeichnis
Code: Alles auswählen
```
/home/david/davidhello/debian
```
Und darin erstellt man die Dateien

Code: Alles auswählen

changelog

Da schreibt man rein

Code: Alles auswählen

hello (0.01) unstable; urgency=low

  * Initial release (Closes: #nnnn)  <nnnn is the bug number of your ITP>

 -- David Vajda <david@ituenix.de>  Mon, 20 Nov 2023 21:34:30 +0100

Bei dem Datum aufpassen - das muss abgesehen vom richtigen Datum, so da stehen

eine
Code: Alles auswählen
```
compat
```
Und da schreibt man die Version rein. Das geht einfach so
Code: Alles auswählen
```
echo "12" >> ./debian/compat
```

Dann braucht man eine

Code: Alles auswählen

control

. Da schreibt man rein

Code: Alles auswählen

Source: hello
Section: misc
Priority: optional
Maintainer: David Vajda david@ituenix.de
Build-Depends: debhelper (>= 8.0.0), autotools-dev
Standards-Version: 3.9.5

Package: hello
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: My First Package

Und zum Schluss eine

Code: Alles auswählen
```
rules
```
. Da schreibt man einfach rein:
Code: Alles auswählen
```
#!/usr/bin/make -f
%:
	dh $@
```
So dann installiert man
Code: Alles auswählen
```
apt-get install packaging-dev
```
Am Ende führt man aus
Code: Alles auswählen
```
dpkg-buildpackage -us -uc 
```
Man hat dann eine Datei
Code: Alles auswählen
```
/home/david/hello_0.01_amd64.deb
```
Und das paket ist fertig. Man kann es installieren mit
Code: Alles auswählen
```
dpkg --install /home/david/hello_0.01_amd64.deb
```
Das Problem ist - es funktioniert prima mit der Installation, auch deinstallation, aber ich weiss nicht, wo die eigentlich ausführbares
Code: Alles auswählen
```
hello
```
gelande ist.

yun7x.de dvajda.de und luckyleaks.org

Artikel Debian

Re: Artikel Debian