So, die Seite ist nun fertig
Und ich habe auch schon
https://www.davidvajda.de/david4
bei den Bildern ersetzt. Ich zeige es im nächsten Beitrag wie.
Code: Alles auswählen
# Mit diesem Bash Skript habe ich alle URL's aber nur bei den Bildern ersetzt
#!/bin/bash
sed 's/https:\/\/davidvajda.de\/david4\//https:\/\/www.ituenix.de\/nextcloud\/data\/dave\/files\/Documents\/david4\//g' davidvajda_dephpbb3.sql > a01.sql
sed 's/https:\/\/www.davidvajda.de\/david4\//https:\/\/www.ituenix.de\/nextcloud\/data\/dave\/files\/Documents\/david4\//g' a01.sql > a02.sql
sed 's/https:\/\/www.davidvajda.de\/david3\//https:\/\/www.ituenix.de\/nextcloud\/data\/dave\/files\/Documents\/david3\//g' a02.sql > a03.sql
sed 's/https:\/\/davidvajda.de\/david3\//https:\/\/www.ituenix.de\/nextcloud\/data\/dave\/files\/Documents\/david3\//g' a03.sql > a04.sql
sed 's/https:\/\/www.davidvajda.de\/david2\//https:\/\/www.ituenix.de\/nextcloud\/data\/dave\/files\/Documents\/david2\//g' a04.sql > a05.sql
sed 's/https:\/\/davidvajda.de\/david2\//https:\/\/www.ituenix.de\/nextcloud\/data\/dave\/files\/Documents\/david2\//g' a05.sql > a06.sql
sed 's/https:\/\/www.davidvajda.de\/david\//https:\/\/www.ituenix.de\/nextcloud\/data\/dave\/files\/Documents\/david\//g' a06.sql > a07.sql
sed 's/https:\/\/davidvajda.de\/david\//https:\/\/www.ituenix.de\/nextcloud\/data\/dave\/files\/Documents\/david\//g' a07.sql > a08.sql
Hier habe ich einen Funktionsplotter selbst gemacht
https://www.davidvajda.de/david/funktionsplotter23.php
Wer da stöbert findet auch Compiler, die Programmiersprachen ganz gut können, aber nicht vollständig implementiert sind
Ich benutze, wie ich Linux benutze, meist fertige Tools, was Homepages betrifft. Ich interessiere mich für das Adminstrieren von Servern. Und Programmiersprachen setze ich gerne um. Der Funktionsplotter tut das. Da sind auch andere kleinere Mathematik Programme. Und ich mache jetzt MMX
Denn mein High Light ist ja jetzt Schaltungen bauen. Letzten Endes passt das gut zu Compilern.
Jetzt MMX.
Hier finden sich meine in PHP geschriebenen Programme, die ich selber schrieb
https://www.davidvajda.de/david/all.html
...
Also, gut ich bespreche das mal so -
wenn wir im Assembler Code
.586 angeben
ich teste gleich mal, ob das mit nasm geht, wird der Pentium-Befehlssatz aktiviert
Um zu testen ob das geht, müssen wir das niedrigste Bit testen. Was in eax ist
Also, mit cpuid können wir verschiedene Dinge Testen. Das tun wir über bits
Wenn ich
Code: Alles auswählen
mov eax, 0000 0001h
cpuid
Nein, ich muss mir zunächst den CPUID Befehl genauer anschauen
Ok, einen Moment. Das hat aber mit MMX so weit erst Mal nichts zu tun. Ob ich den .586 Befehlssatz benutzen kann, verrät CPUID und dann ist MMX vorhanden
MMX geht dann so
Code: Alles auswählen
movq mm0, SUMMAND1
movq mm1, SUMMAND2
paddusb mm0, mm1
OK, ich schaue mal.
OK, ich sehe, ich muss viele Register lernen. Dazu gehören
1.) Das Flag Register wurde stark erweitert
2.) Maschinenstatuswort MSW
3.) Kontroll-Register
4.) Debug-Register
5.) Modellspezifische Register
Also, jetzt erst Mal der CPUID Befehl
Also,
1.) Ich kann ohne den CPUID Befehl zu nehmen, also, noch keinen CPUID Befehl, kann ich testen, ob der überhaupt verfügbar ist - das ist logisch - ob der überhaupt da ist - dazu verwende ich keinen CPUID Befehl, aber ich verwende Bit 21 des EFlag Registers
2.) Vorsicht nicht verwechseln, um den Pentium Befehlssatz zu aktivieren, verwende ich Bit 23. Das muss ich dann auch testen, ob überhaupt vorhanden
Vorsicht Bit 21 und Bit 23, das ist wie ssl und ssh. Der Unterschied zwischen ssl und ssh ist mir ja klar, blos, dass beide so ähnlich schlüssel verwenden. Ich wäre mal gespannt, ob es in C funktionen gibt, die Schlüssel implementieren.
Natürlich, keine Sorge, ich lasse bei meinem Programm nicht nach, ich schliesse nach wie vor das EEPROM an den Zilog Z80 an und lerne Zilog Z80 Befehlssatz und schreibe Harmlose x86 Programme. Und lerne das LCD. Aber trotzdem lerne ich noch was der CPUID macht und gucke schon mal, was man da so kann. Ich lerne schon im Vorraus. Ich frage nicht nach.
Gut, das probiere ich mal aus.
Mit Öffentlich geteilt
Ich schreibe gleich mal ein Programm, was meine Prozessor Kennung ausgibt.
Diese steht bei code 0, in ebx, ecx, edx.
Es hat funktioniert!!!
Code: Alles auswählen
global _start
section .data
outstr: db "____________", 0x00
outstrlen: equ $-outstr
section .text
_start:
section .568
mov eax, 0x00
cpuid
mov edi, outstr
mov [edi], ebx
inc edi
inc edi
inc edi
inc edi
mov [edi], ecx
inc edi
inc edi
inc edi
inc edi
mov [edi], edx
mov edx, outstrlen
mov ecx, outstr
mov ebx, 1
mov eax, 4
int 0x80
mov ebx, 0
mov eax, 1
int 0x80Code: Alles auswählen
david@laptop-peaq:~$ nasm -f elf32 -g cpuid001.asm
david@laptop-peaq:~$ ld -m elf_i386 -g cpuid001.o
david@laptop-peaq:~$ ./a.out
GenuntelineI
david@laptop-peaq:~$
OK, alles klar - das ist eine etwas spezifische Extra Angelenheit, zu testen, ob der CPUID Befehl überhaupt da ist, auf jeder modernen Maschine wäre er da.
Ich habe jetzt nicht getestet, ob er da ist - ich habe ihn einfach verwendet. Dann ist es ganz einfach
Ansonsten ist CPUID ganz einfach. Ich schreibe in EAX einen Wert - 0 steht der Herstellername als String angegeben
Das ist in der CPU fest verdrahtet
Und der Rest gibt irgendetwas wieder. Im EFlag-Register stehen Infos Bit 23 steht für MMX und so weiter. Oder in EAX steht drin, was das für eine CPU ist, genauer nicht als Name, sondern als Nummer.
Gut im nächsten Schritt probiere ich MMX aus. Dafür habe ich mir was ausgedacht
Ich kann ja die Reihe
1+1+1+1+1
Berechnen
Dazu die Reihe
2+2+2+2+2
Dann die Reihe
3+3+3+3+3
Normalerweise müsste ich 8 mal für die gesamten Reihen rechnen. Ich probiere jetzt MMX aus
Dann muss ich das nur in Zahlen umrechnen, weil ich es sonst nicht darstellen kann, ich habe drei Möglichkeiten
1.) Ich mache die Umrechnung für Darstellung selber
2.) Ich integriere das ganze in GCC
3.) Ich gebe es hexadezimal aus
Ich entscheide mich für letzteres.
Ich muss bei heutigen CPU's nicht mit CPUID testen, ob MMX vorhanden, ich gehe in meinem Falle mal davon aus. Für sinnvolle Apps, muss man das aber abfragen.
Code: Alles auswählen
;; Also, ich habe herausgefunden, das geht so nicht, ich kann movq so nicht verwenden
global _start
section .data
summand1 dq 0001020304050607h
summand2 dq 0000000000000000h
summe: db '________'
outstrlen: equ $-summe
section .text
_start:
section .568
section .mmx
movq mm0, summand1
movq mm1, summand2
paddusb mm0, mm1
paddusb mm0, mm1
paddusb mm0, mm1
paddusb mm0, mm1
paddusb mm0, mm1
movq summe, mm1
mov edx, outstrlen
mov ecx, summe
mov ebx, 1
mov eax, 4
int 0x80
mov ebx, 0
mov eax, 1
int 0x80
Ja, Entschuldigung, ich leite keine Daten weiter, die nicht zumindest von mir stammen. dass ich den CPUID Befehl heraus gesucht habe, genauso wie MMX - ich finde das gehört (1.) zu meinen Thema - ich realisiere ja gerade den MIPS32 auf FPGA in VHDL und mache den Z80 an das LCD - das ist was anderes (2.) Ich benutze Linux nur - ich gebe da nichts weiter. Ich benutze das nachher in meiner Homepage, damit die tut (3.) Wenn überhaupt dann sind das Dinge aus dem eigenen Kopf, die ich mir wahrscheinlich selber ausdachte - wie zum Beispiel
bei meinen SQL Funktionen - die Idee mit De Morgan und der Menge.
Das Programm zu cpuid habe ich übrigens selbst geschrieben und ist nicht abgeschrieben, da weit das geht, die Befehle habe nicht erfunden.
Aber das mit Strings habe ich so selbst gemacht.
Erst Mal Rückmeldung
1.) So schwer ist das mit gpg und pgp nicht zu verstehen - zertifkaten und Co - ich weiss das schon, aber ich brauche noch ein bisschen Ordnung
2.) CPUID und MMX ist schnell zu verstehen
Zu (2.) Ich habe mir CPUID genau angeschaut. Das erste ist, wir haben eine Funktionsnummer - üblicherweise 0x00, 0x01, aber auch 0x02, 0x03. Die schreiben wir in EAX und führen den CPUID Befehl aus
Das ist nicht schwer zu verstehen. Bei 0x00 erhalten wir die Ausgabe wie vorher. Einen String, den der Hersteller liefert.
Die Bits bei 0x01 in EDX kann man alle verstehen
Zum Beispiel: Wenn man Computersysteme I/II gerlernt hat, kann man mit dem Cache umgehen. Das bedeutet - Es gibt
1.) Write Through - Durchschreibeverfahren - ich fahre durch die Stadt durch in die nächste - diesen Satz habe ich erfunden
2.) Umschreibeverfahren: Ich fahre um die Stadt herum in die Nächste
3.) Write Back - Rückschreibeverfahren: Ich fahre an der Stadtgrenze der ersten Stadt zurück und nicht in die nächste
Wenn man das verstanden hat, und wie der Cache geht, versteht man einige Bits ganz einfach. Diese gehören übrigens glaube ich gerade nicht zu dem CPUID - sondern zu den Flags
Wir können zwischen Write Through und Write Back umschalten
Das Paging habe ich mal mit Assembler ausprobiert
Genau wie Register EAX und EBX heissen, heissen Register CR0 bis CR5. oder 4. Das sind einfach Control Register
Ich habe Paging mal programmiert, es war einfach
Ich kann es noch mal machen
Gut, mit CPUID können wir so Sachen ausführen, wie ob er 4 MByte Pages unterstütz - oder auch PAE - Physical Address Extension - das bedeutet auf einer Maschine mit 32 Bit, können wir Addressen über 4 GByte RAM ansprechen.
Oder - es gibt für die CPU zwei Bits zur Termischen Überwachung. Zwei Bits, die die Termische Überwachung und steuerung erlauben, so etwas können wir damit machen
Ob MMX vorhanden ist, signalisiert Bit 23
Gut, das ist nicht schwer
MMX habe ich auch verstanden
Es gibt halt die Register MM0, bis MM7
Und der Witz ist - dass es Mathematische Befehle gibt
die heissen zum Beispiel PADD - oder POR, PAND
Vor dem Befehl steht ein P
dann gibt es Befehle zum Packen und Entpacken
Zum Packen beginnen sie mit PACK zum Entpacken mit PUPCK...
Was komisch aussieht ist es nicht. P voran
UPCK steht für UNPACK
Dann gibt es Befehle zum Bewegen
MOVQ und so weiter
Kein Problem
1.) Jetzt zu den Schlüsseln
Wir müssen halt wissen, das weiss ich schon, was ich jetzt schreibe weiss ich schon - und ich kann es auch anwenden. ich habe ein Problem mit Schlüsseln, wo die bei Linux gespeichert werden. Also, mit der Sache selbst habe ich kein Problem
Aber die Schlüssel werden bei Linux irgendwo in /home/david/....
gespeichert. Sind diese Schlüssel auch austauschbar
Kann ich etwa den Schlüssel von SSH in SSL irgendwie verwenden. Das ist meine Frage
Also, erstens: Zur verschlüsselung
Einen Text kann ich so verschlüsseln
abc
Ich addiere ein a
Dann habe ich
bcd
Gut, ich kann weiter gehen und mit
xyz verschlüsseln
Das ist ein normales Verschlüsselungsverfahren. Diese Verschlüsselungsverahren heissen synchron. Zum Entschlüsseln wird derselbe Schlüssel verwendet, wie zum Verschlüsseln
Von
bcd
ziehe ich a ab
Ein Asynchrones Verschlüsselungsverfahren geht anders
Ich verwende nicht den Schlüssel zum Entschlüsseln, wie ich ihn zum Verschlüsseln verwendete
Dahinter steckt ein Algorithmus, der auf sehr viel Mathematik beruht. Es ist möglich ihn praktisch mit sehr kleinen Primzahlen aus zu probieren. die braucht es. Exemplarisch als Übung
Dabei kann man allerdings den Gedankengang hinter der Mathematik noch nicht automatisch nach vollziehen, auf den ersten Blick. In der Realität verwenden wir grosse Primzahlen
Jedenfalls haben wir
1.) Einen Schlüssel zum Verschlüsseln
2.) Einen Schlüssel zum Entschlüsseln
1.) Einen öffentlichen Schlüssel
2.) Einen privaten
Vorsicht. Wir haben noch etwas
1.) Sender
2.) Empfänger.
Die Sache funktioniert nur in eine Richtung. Bei einem Synchronen Schlüsselverfahren, müssen sowohl Sender als auch Empfänger den Schlüssel besitzen und es ist ganz egal wer ihn generiert hat
Der witz, beim Asynchronen
1.) Erstellen tut den Schlüssel, der Empfänger, nicht der Sender
2.) Dieser Schlüssel ist öffentlich
3.) Der Sender verschlüsselt die Nachricht mit dem öffentlichen schlüssel
4.) Der Empfänger entschlüsselt die Nachricht mit dem privaten
Damit müssen privater und öffentlicher Schlüssel zusammen gehören. Sie wurden zusammen generiert
Dabei hat der Empfänger den Schlüssel frei gegeben und der Sender benutzt ihn, um die Nachricht zu verschlüsseln. Diesse kann jetzt nicht mehr geknackt werden, mit dem Schlüssel, der öffentlich war und zum Verschlüsseln
Der Empfänger entschlüsselt die Nachricht mit dem Privaten
a) So, bei einer Homepatge ist es so
1.) es gibt SSL
2.) Eine Website wird nicht etwa so verschlüsselt dass der Inhalt der Homepage verschlüsselt wird. Also nicht das HTML. Das wäre komisch. Jeder kann auf die Homepage, warum verschlüsseln?
3.) Aber der Nutzer gibt Daten ein. Zum Beispiel bei der Bank. Wenn er diese unverschlüsselt über das Netz überträgt können sie mitgelesen werden
Nicht etwa, die Homepage der Bank wird verschlüsselt ,damit sie keiner sieht, sondern, das was der Nutzer an IBAN's und Passwörtern eingibt
Dazu gibt es einen öffentlichen Schlüssel
Den hat die Homepage. Geht man auf die Homepage. Ruft der Browser den Schlüssel ab. Damit verschlüsselt der User seine eingegeben Daten. Diese werde zur Homepage übertragen
Was der User hat ist der öffentliche Schlüssel und damit verschlüsselt er automatisch im Browser die eingegeben Daten, nicht anders herum. Die Bank empfängt die Daten. Und mit ihrem Privaten Schlüssel wird es entschlüsselt.
Jetzt zu SSL
Im Gegensatz zu SSH - wo eigentlich nicht jeder in das System rein kommt - SSL entspricht HTTPS - SSH - entspricht der Shell, über das Netzwerk
braucht es Zertifikate. Denn eine Homepage kann etwas vortäuschen. Sie kann die Verschlüsselung vortäuschen
Hier muss ich genauer gucken. Also gibt es Zertifikate
Das Problem ist - wer erstellt die Zertifkate
Dafür gibt es eine CA - typisch amerikanisches Wort - CA - Certificate Authority - Zertifizierungsstelle
Wir haben
1.) Privaten Schlüssel
2.) öffentlichen Schlüssel
3.) Zertifikat
Damit das Zertifkat ausgestellt werden kann, braucht es eine CA
Damit haben wir von der CA aber mehr, als nur den Schlüssel
1.) Schlüssel
2.) Zertifikat
Die CA ist dazu da, Zertifikate zu erstellen. Aber die Schlüssel müssen auch her. Zum Schlüssel wird ein Zertifkat erstellt.
Gut, wir haben öffentlichen und nicht öffentlichen Schlüssel
Privat und Öffentlich
Alles, was so funktioniert, heisst PGP - Pritty Good Privacy.
Das sind aber unterschiedliche dinge, ob ich
1.) SSL
2.) SSH
3.) GPG
verwende. GPG ist PGP - ein Programm, was unabhängig einer Anwendung - SSH und HTTPS sind Anwendungen, verwendet werden kann, um zum Beispiel Texte zu verschlüsseln.
Wenn ich ihnen eine E-Mail schicke und sie bieten mir einen öffentlichen Schlüssel an, kann ich die Mail nehmen und den Inhalt verschlüsselt schicken. Das mache ich nicht mit der Mail an sich
der Mail Header bleibt erhalten. Das hat damit nichts zu tun. Ich verschlüssele irgendeinen Inhalt und versende ihn so
HTTPS ist eine Anwendung, die braucht Zertifiakte, weil jeder jederzeit auf eine Homepage zu greifen kann. Dabei aber sensible Daten von irgendwo her übertragen werden
Deswegen braucht es bei SSL - Zertifikate und CA
Das braucht es bei SSH gar nicht. Und bei GPG auch nicht
Mit GPG mache ich es selber. Mit SSH verwende ich auch schlüssel, die ich austausche
Ich habe mir aber noch keine Gedanken gemacht, ob ich die Schlüssel unter den Programmen austauschen kann. und ich habe mir keine Gedanken gemacht, welches Programm SSH zur Generierung von Schlüsseln verwendet, ein eigenes? Gleich mal nachschauen.
ssh-keygen -t rsa -b 4096
Ja, ich habe nachgeschaut. und da steht es. Es ist etwas verwirrend und ich muss sagen, ich habe mir eben nicht viel Zeit genommen
Hier steht:
ssh-keygen
Also ssh - keygen. Und den Unterschied muss man beachten. Es erleichtert mich
Da steht aber ssh-keygen. Es ist also ein Programm von ssh, was die Schlüssel generiert. SSH selber. Nicht ein allgemeines Programm zur Erstellung von Schlüsseln. Da habe ich nicht lange genug hingeschaut
Der Witz ist nämlich
ssh-keygen -t rsa -b 4096
Wenn man sich das anschaut
ssh-keygen -t rsa -b 4096
sieht er vielen Befehlen zur Schlüsselgenerierung ähnlich. RSA das muss man sich merken, ist einfach ein Algorithmus zur Verschlüsselung. Es ist halt einer. Man könnte ihn selber nachprogrammieren. Aber mit dem 4096 und RSA sieht es aus, wie jedes beliebige Programm zur Verschlüsselung
das hat mich durcheinander gebracht. Und - es gibt aber Dinge, die ich noch nicht gut weiss
Etwa, was ist ein Fingerprint
ich kann mit gpg umgehen und ich habe es öfter getestet
Jetzt kam die Prüfung, ich musste alle Zeit investieren. Ich habe mit gpg geübt und es hat gut funktioniert
Ich habe damit geübt, es hat funktioniert. Ich musste aufhören
Ich reihe es ein, zu den Übungen mit
bash
/etc/init.d
gpg
aber auch
lvm
ich richte jeden Tag LVM auf zwei USB-Sticks ein
Und festplatten Verschlüsselung mit Luks übe ich auch an denen.
Die Seite mit zertbot und zertifikaten als SSL und HTTPS sicher zu machen, wie ich bei
https://www.ituenix.de
ist übrigens kein Problem. Ich kann eigene Zertifkate erstellen und eine CA. Allerdings nicht aus dem Kopf, das ist ein Unterschied. Aber für die Homepage verwendet man keine eigenen Zertifkate, sonst, gilt die Homepage trotzdem als unsicher. Zertifkate müssen anerkannt sein, ausser bei einem selber, sonst gelten sie als unsicher
HTTPS einrichten, mit den fremden Zertifikaten von certbot ist kein Problem.