# fckeuspy-go

## Co to je

Nástroj v Go pro asymetrické šifrování zpráv cizím veřejným klíčem.

Má dvě rozhraní:

1. Web (HTMX) – jednoduché formuláře (encrypt / decrypt)
2. Desktop (Fyne v2) – 4 záložky: Skenovat chat, Identita, Kontakty, Dešifrování (dark UI)

Vlastnosti:

* Při startu vygeneruje nebo načte RSA identitu (2048 bitů)
* Sdílí veřejný klíč (`public.pem`) a self‑signed cert (`identity.crt`)
* Hybridní šifra: **RSA-OAEP (SHA-256) + AES-256-GCM**
* JSON payload: `{ek,n,ct}` (base64 komponenty)
* V GUI nad každým polem sada tlačítek (Paste, Clear, Encrypt/Decrypt, Copy)
* Output pole jsou read‑only
* Pamatuje poslední záložku a velikost okna

---

## Požadavky

* Go 1.21+
* Není potřeba databáze ani další služby
* Pro výběr oblasti obrazovky v GUI na Waylandu doporučeno `grim` + `slurp`

---

## Rychlý start (GUI)

Volitelné balíčky pro snímání části obrazovky přímo z desktop GUI:

```bash
sudo apt update
sudo apt install grim slurp
```

Ověření:

```bash
grim --version
slurp --version
```

Na Ubuntu GNOME může místo toho stačit i fallback:

```bash
sudo apt install gnome-screenshot
```

```bash
# 1) po buildnutí (go build .) stačí spustit binárku – otevře se GUI
./fckeuspy-go

# Alternativně přes go run
go run . gui
```

Na prvním startu se vytvoří:

```text
identity_key.pem   # RSA private key (PKCS#1)
public.pem         # veřejný klíč PEM (PKIX)
identity.crt       # self-signed cert (vizitka)
```

---

## Regenerace klíčů

Pokud chceš vygenerovat novou identitu:

```bash
# přes flag
go run . -regen

# nebo přes env proměnnou
REGEN_KEYS=1 go run .
```

---

## Web UI použití

```bash
# přes flag
go run . web
```


1. Otevři `http://localhost:8080/`
2. Zkopíruj / stáhni svůj veřejný klíč nebo cert
3. Do Encrypt formuláře vlož cizí public key/cert + zprávu → Encrypt
4. JSON payload odešli příjemci
5. Příjemce vloží payload do Decrypt → plaintext

Formát payloadu:

```json
{
  "ek": "base64(RSA-OAEP(aesKey))",
  "n":  "base64(nonce)",
  "ct": "base64(aes-gcm-ciphertext)"
}
```

---

## HTTP endpointy

* `GET /` – hlavní UI (HTMX)
* `GET /public.pem` – veřejný klíč PEM
* `GET /public.crt` – self-signed cert PEM
* `POST /encrypt` – form fields:

  * `message` – plaintext
  * `pubkey` – cílový veřejný klíč (PEM `PUBLIC KEY` nebo `CERTIFICATE`)
* `POST /decrypt` – form field:

  * `payload` – JSON se strukturou `{"ek","n","ct"}`
* `GET /static/style.css` – CSS

---

## Struktura projektu (zkráceně)

```text
.
├─ main.go          # cobra entry
├─ cmd.go           # CLI příkazy (gui, web)
├─ ui.go            # Fyne komponenty
├─ fyne_ui.go       # init okna + prefs
├─ server.go        # HTTP handlery
├─ lib/crypto.go    # šifrovací logika
├─ templates/       # HTMX šablony
└─ static/          # CSS
```

---

## Bezpečnostní poznámky

* Soukromý klíč se ukládá lokálně (`identity_key.pem`, chmod 600).
* Certifikát je jen vizitka (není pro TLS).
* Použitý algoritmus: RSA-OAEP se SHA-256 + AES-GCM.
* Pro produkci bys měl řešit: správu identit, heslem chráněný export, rotaci klíčů.

---

## Tipy

* „Copy“ používá **Clipboard API** (funguje na `localhost`).
* „Clear“ vyprázdní textareu.
* Layout: mobil → 1 sloupec, desktop → 2 sloupce.

---

## Spuštění (GUI / Web)

Spuštění desktopu (GUI):

```bash
# po buildnutí (go build .)
./fckeuspy-go

# nebo přes go run
go run . gui
```

Záložky:

1. Skenovat chat – výběr oblasti obrazovky / schránka / soubor, čtení QR a dešifrování nalezených payloadů
2. Identita – kopírování `public.pem` / `identity.crt`
3. Kontakty – správa kontaktů a jejich certifikátů
4. Dešifrování – ruční vložení payloadu: Paste+Decrypt, Clear (čistí i výsledek), Copy

GUI je trvale v dark stylu. Pamatuje poslední tab a velikost okna.

HTTP režim zůstává:

```bash
go run . web
# nebo po buildnutí (go build .)
./fckeuspy-go web
```

---

---



## Jak to funguje podle chatGPT

Ok, pojďme úplně jednoduše, krok za krokem – bez odborných keců 👇

---

## Jak to celé funguje

1. **Máš dva klíče**:

   * **soukromý klíč** (jen pro tebe, musíš ho schovat)
   * **veřejný klíč** (můžeš poslat komukoli)

2. Když ti někdo chce poslat zprávu:

   * vezme tvůj veřejný klíč
   * vytvoří si jednorázový **tajný kód (klíč)** pro šifrování
   * ten kód uzamkne tvým veřejným klíčem (aby ho uměl odemknout jen tvůj soukromý klíč)
   * zprávu zašifruje tím jednorázovým kódem

3. Ty zprávu dostaneš:

   * odemkneš si tím svým **soukromým klíčem** ten jednorázový kód
   * a tím kódem si dešifruješ samotnou zprávu

💡 Proč to takhle? Protože šifrovat velké zprávy přímo RSA by bylo pomalé a nepraktické. Proto se vždycky kombinuje:

* RSA jen na uzamčení malého tajného klíče,
* rychlý algoritmus (AES) na šifrování celé zprávy.

---

### Jak silné to je (2025)

* **RSA 2048 bitů**

  * to je ta „velká matematika“ (pracuje s obrovskými prvočísly)
  * dnes to *nikdo na světě neumí rozlousknout* běžnými prostředky
  * odhady: kdybys měl všechny počítače světa, tak bys to lámal tisíce let
  * pro běžnou komunikaci je to **naprosto bezpečné**

* **AES 256 bitů**

  * to je ten rychlý algoritmus na zprávy
  * 256 bitů = tak obrovské množství možností, že brute force (zkoušet všechny klíče) je nereálný i s kvantovým počítačem, co si dnes umíme představit
  * používají to banky, armády i vlády

---

### Přirovnání

* Tvůj systém = **dvě zámky**:

  1. RSA je jako **trezor s klíčem** – jen ty máš správný klíč (soukromý).
  2. AES je jako **řetěz a visací zámek na balíku zprávy** – kód k odemčení toho visacího zámku je schovaný v trezoru.

* Útočník by musel buď:

  * **vykrást trezor RSA 2048** (prakticky nemožné),
  * nebo **prolomit AES 256** (prakticky nemožné).

---

### Shrnutí

* To, co máš teď, je na úrovni **toho, co reálně používá PGP, banky a vlády**.
* **Prolomení?**:

  * Dnes = nerealistické
  * Do cca 2030 = pořád v pohodě (RSA 2048)
  * Pokud chceš být „future-proof“ na desítky let, můžeš jít na **RSA 3072 nebo 4096** (je to jen pomalejší).

---



## Jak je to s certifikaty podle chatGPT

## `identity_key.pem`

* **Soukromý klíč** (private key)
* Tenhle soubor je jen pro tebe.
* Obsahuje čísla, kterými dokážeš:

  * odemknout zprávy, co ti někdo zašifroval tvým veřejným klíčem
  * (a kdybys chtěl, tak i podepisovat zprávy, aby bylo vidět, že jsi je poslal ty)
* **NESMÍŠ** to nikomu posílat. Když to někdo získá, může číst všechny tvoje zprávy.
* Je to nejcennější část tvé identity.

---

## `public.pem`

* **Veřejný klíč** (public key)
* To je „vizitka“, kterou pošleš ostatním.
* Pomocí něj ti ostatní **zašifrují zprávu**.
* Bez tvého soukromého klíče ji nikdo jiný nerozluští.
* Je to čistě klíč, bez dalších informací.

---

## `identity.crt`

* **Certifikát** (self-signed = podepsaný sám sebou)
* Je to vlastně balíček, který obsahuje:

  * tvůj veřejný klíč
  * plus pár informací „kdo jsi“ (u nás jen jednoduché jméno *Encryptor Local Identity*)
  * a podpis tím tvým soukromým klíčem → to ukazuje, že to opravdu patří k sobě
* Prakticky slouží taky jen ke sdílení tvého veřejného klíče, ale v „certifikátové podobě“.
* Výhoda: některé aplikace umí pracovat s certifikáty rovnou, aniž by řešily syrový public key.

---

## Shrnutí v řeči pro normální lidi

* `identity_key.pem` → **tajný klíč** = schovej do trezoru, nikomu nedávej.
* `public.pem` → **veřejný klíč** = pošli komukoli, aby ti mohl šifrovat zprávy.
* `identity.crt` → **certifikát** = taky můžeš poslat lidem, je to jen jiná „obalená“ forma veřejného klíče.

---
