Re:

So, die Seite ist nun fertig

Und ich habe auch schon

https://www.davidvajda.de/david4">https://www.davidvajda.de/david4</URL>

bei den Bildern ersetzt. Ich zeige es im naechsten Beitrag wie.

\begin{verbatim}
# 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

Wie gesagt, ich verschwende nicht so viel Zeit in das Entwickeln von Homepages

Hier habe ich einen Funktionsplotter selbst gemacht

Wer da stoebert findet auch Compiler, die Programmiersprachen ganz gut koennen, aber nicht vollstaendig implementiert sind

Ich benutze, wie ich Linux benutze, meist fertige Tools, was Homepages betrifft. Ich interessiere mich fuer 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

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, muessen wir das niedrigste Bit testen. Was in eax ist

Also, mit cpuid koennen wir verschiedene Dinge Testen. Das tun wir ueber bits

Wenn ich

mov eax, 0000 0001h
cpuid

aufrufe.

Nein, ich muss mir zunaechst 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, verraet CPUID und dann ist MMX vorhanden

MMX geht dann so

movq mm0, SUMMAND1
movq mm1, SUMMAND2
paddusb mm0, mm1

Das heisst, einfach, dass SUMMAND1 so breit ist, dass 8 Byte rein passen, die aber einzeln addiert werden

OK, ich schaue mal.

OK, ich sehe, ich muss viele Register lernen. Dazu gehoeren

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 ueberhaupt verfuegbar ist - das ist logisch - ob der ueberhaupt 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 ueberhaupt 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 aehnlich schluessel verwenden. Ich waere mal gespannt, ob es in C funktionen gibt, die Schluessel implementieren.

Natuerlich, 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 OEffentlich geteilt Ich schreibe gleich mal ein Programm, was meine Prozessor Kennung ausgibt. Diese steht bei code 0, in ebx, ecx, edx.

Es hat funktioniert!!!

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 0x80

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 ueberhaupt da ist, auf jeder modernen Maschine waere 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 fuer MMX und so weiter. Oder in EAX steht drin, was das fuer eine CPU ist, genauer nicht als Name, sondern als Nummer.

Gut im naechsten Schritt probiere ich MMX aus. Dafuer 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 muesste ich 8 mal fuer 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 Moeglichkeiten

1.) Ich mache die Umrechnung fuer Darstellung selber 2.) Ich integriere das ganze in GCC 3.) Ich gebe es hexadezimal aus

Ich entscheide mich fuer letzteres.

Ich muss bei heutigen CPU's nicht mit CPUID testen, ob MMX vorhanden, ich gehe in meinem Falle mal davon aus. Fuer sinnvolle Apps, muss man das aber abfragen.

;; 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 gehoert (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 ueberhaupt 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 uebrigens 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 Rueckmeldung

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 - ueblicherweise 0x00, 0x01, aber auch 0x02, 0x03. Die schreiben wir in EAX und fuehren 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 naechste - diesen Satz habe ich erfunden 2.) Umschreibeverfahren: Ich fahre um die Stadt herum in die Naechste 3.) Write Back - Rueckschreibeverfahren: Ich fahre an der Stadtgrenze der ersten Stadt zurueck und nicht in die naechste

Wenn man das verstanden hat, und wie der Cache geht, versteht man einige Bits ganz einfach. Diese gehoeren uebrigens glaube ich gerade nicht zu dem CPUID - sondern zu den Flags

Wir koennen 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 koennen wir so Sachen ausfuehren, wie ob er 4 MByte Pages unterstuetz - oder auch PAE - Physical Address Extension - das bedeutet auf einer Maschine mit 32 Bit, koennen wir Addressen ueber 4 GByte RAM ansprechen.

Oder - es gibt fuer die CPU zwei Bits zur Termischen UEberwachung. Zwei Bits, die die Termische UEberwachung und steuerung erlauben, so etwas koennen 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 fuer UNPACK

Dann gibt es Befehle zum Bewegen

MOVQ und so weiter

Kein Problem

1.) Jetzt zu den Schluesseln

Wir muessen halt wissen, das weiss ich schon, was ich jetzt schreibe weiss ich schon - und ich kann es auch anwenden. ich habe ein Problem mit Schluesseln, wo die bei Linux gespeichert werden. Also, mit der Sache selbst habe ich kein Problem

Aber die Schluessel werden bei Linux irgendwo in /home/david/....

gespeichert. Sind diese Schluessel auch austauschbar

Kann ich etwa den Schluessel von SSH in SSL irgendwie verwenden. Das ist meine Frage

Also, erstens: Zur verschluesselung

Einen Text kann ich so verschluesseln

abc

Ich addiere ein a

Dann habe ich

bcd

Gut, ich kann weiter gehen und mit

xyz verschluesseln

Das ist ein normales Verschluesselungsverfahren. Diese Verschluesselungsverahren heissen synchron. Zum Entschluesseln wird derselbe Schluessel verwendet, wie zum Verschluesseln

Von

bcd

ziehe ich a ab

Ein Asynchrones Verschluesselungsverfahren geht anders

Ich verwende nicht den Schluessel zum Entschluesseln, wie ich ihn zum Verschluesseln verwendete

Dahinter steckt ein Algorithmus, der auf sehr viel Mathematik beruht. Es ist moeglich ihn praktisch mit sehr kleinen Primzahlen aus zu probieren. die braucht es. Exemplarisch als UEbung

Dabei kann man allerdings den Gedankengang hinter der Mathematik noch nicht automatisch nach vollziehen, auf den ersten Blick. In der Realitaet verwenden wir grosse Primzahlen

Jedenfalls haben wir

1.) Einen Schluessel zum Verschluesseln 2.) Einen Schluessel zum Entschluesseln

1.) Einen oeffentlichen Schluessel 2.) Einen privaten

Vorsicht. Wir haben noch etwas

1.) Sender 2.) Empfaenger.

Die Sache funktioniert nur in eine Richtung. Bei einem Synchronen Schluesselverfahren, muessen sowohl Sender als auch Empfaenger den Schluessel besitzen und es ist ganz egal wer ihn generiert hat

Der witz, beim Asynchronen

1.) Erstellen tut den Schluessel, der Empfaenger, nicht der Sender 2.) Dieser Schluessel ist oeffentlich 3.) Der Sender verschluesselt die Nachricht mit dem oeffentlichen schluessel 4.) Der Empfaenger entschluesselt die Nachricht mit dem privaten

Damit muessen privater und oeffentlicher Schluessel zusammen gehoeren. Sie wurden zusammen generiert

Dabei hat der Empfaenger den Schluessel frei gegeben und der Sender benutzt ihn, um die Nachricht zu verschluesseln. Diesse kann jetzt nicht mehr geknackt werden, mit dem Schluessel, der oeffentlich war und zum Verschluesseln

Der Empfaenger entschluesselt die Nachricht mit dem Privaten

a) So, bei einer Homepatge ist es so

1.) es gibt SSL 2.) Eine Website wird nicht etwa so verschluesselt dass der Inhalt der Homepage verschluesselt wird. Also nicht das HTML. Das waere komisch. Jeder kann auf die Homepage, warum verschluesseln? 3.) Aber der Nutzer gibt Daten ein. Zum Beispiel bei der Bank. Wenn er diese unverschluesselt ueber das Netz uebertraegt koennen sie mitgelesen werden

Nicht etwa, die Homepage der Bank wird verschluesselt ,damit sie keiner sieht, sondern, das was der Nutzer an IBAN's und Passwoertern eingibt

Dazu gibt es einen oeffentlichen Schluessel

Den hat die Homepage. Geht man auf die Homepage. Ruft der Browser den Schluessel ab. Damit verschluesselt der User seine eingegeben Daten. Diese werde zur Homepage uebertragen

Was der User hat ist der oeffentliche Schluessel und damit verschluesselt er automatisch im Browser die eingegeben Daten, nicht anders herum. Die Bank empfaengt die Daten. Und mit ihrem Privaten Schluessel wird es entschluesselt.

Jetzt zu SSL

Im Gegensatz zu SSH - wo eigentlich nicht jeder in das System rein kommt - SSL entspricht HTTPS - SSH - entspricht der Shell, ueber das Netzwerk

braucht es Zertifikate. Denn eine Homepage kann etwas vortaeuschen. Sie kann die Verschluesselung vortaeuschen

Hier muss ich genauer gucken. Also gibt es Zertifikate

Das Problem ist - wer erstellt die Zertifkate

Dafuer gibt es eine CA - typisch amerikanisches Wort - CA - Certificate Authority - Zertifizierungsstelle

Wir haben

1.) Privaten Schluessel 2.) oeffentlichen Schluessel 3.) Zertifikat

Damit das Zertifkat ausgestellt werden kann, braucht es eine CA

Damit haben wir von der CA aber mehr, als nur den Schluessel

1.) Schluessel 2.) Zertifikat

Die CA ist dazu da, Zertifikate zu erstellen. Aber die Schluessel muessen auch her. Zum Schluessel wird ein Zertifkat erstellt.

Gut, wir haben oeffentlichen und nicht oeffentlichen Schluessel

Privat und OEffentlich

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 unabhaengig einer Anwendung - SSH und HTTPS sind Anwendungen, verwendet werden kann, um zum Beispiel Texte zu verschluesseln.

Wenn ich ihnen eine E-Mail schicke und sie bieten mir einen oeffentlichen Schluessel an, kann ich die Mail nehmen und den Inhalt verschluesselt schicken. Das mache ich nicht mit der Mail an sich

der Mail Header bleibt erhalten. Das hat damit nichts zu tun. Ich verschluessele 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 uebertragen 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 schluessel, die ich austausche

Ich habe mir aber noch keine Gedanken gemacht, ob ich die Schluessel unter den Programmen austauschen kann. und ich habe mir keine Gedanken gemacht, welches Programm SSH zur Generierung von Schluesseln 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 Schluessel generiert. SSH selber. Nicht ein allgemeines Programm zur Erstellung von Schluesseln. Da habe ich nicht lange genug hingeschaut

Der Witz ist naemlich

ssh-keygen -t rsa -b 4096

Wenn man sich das anschaut

ssh-keygen -t rsa -b 4096

sieht er vielen Befehlen zur Schluesselgenerierung aehnlich. RSA das muss man sich merken, ist einfach ein Algorithmus zur Verschluesselung. Es ist halt einer. Man koennte ihn selber nachprogrammieren. Aber mit dem 4096 und RSA sieht es aus, wie jedes beliebige Programm zur Verschluesselung

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 oefter getestet

Jetzt kam die Pruefung, ich musste alle Zeit investieren. Ich habe mit gpg geuebt und es hat gut funktioniert

Ich habe damit geuebt, es hat funktioniert. Ich musste aufhoeren

Ich reihe es ein, zu den UEbungen mit

bash /etc/init.d gpg

aber auch

lvm

ich richte jeden Tag LVM auf zwei USB-Sticks ein

Und festplatten Verschluesselung mit Luks uebe ich auch an denen.

Die Seite mit zertbot und zertifikaten als SSL und HTTPS sicher zu machen, wie ich bei

ist uebrigens kein Problem. Ich kann eigene Zertifkate erstellen und eine CA. Allerdings nicht aus dem Kopf, das ist ein Unterschied. Aber fuer die Homepage verwendet man keine eigenen Zertifkate, sonst, gilt die Homepage trotzdem als unsicher. Zertifkate muessen anerkannt sein, ausser bei einem selber, sonst gelten sie als unsicher

HTTPS einrichten, mit den