Creare un AppImage firmata di un progetto Gambas

Da Gambas-it.org - Wikipedia.

Questa lezione iniziata da Akrobaticone a seguito di questo suo post https://www.gambas-it.org/smf/index.php?topic=10305.msg53503#msg53503 e da questa mia successiva richiesta di poter firmare le AppImage: http://gambaswiki.org/bugtracker/edit?object=BUG.2890&from=L21haW4
Tale richiesta nasce da una riflessione fatta con l'Ing. Claus Dietrich coautore dal 2015 del libro tedesco su Gambas del Prof. Hans Lehmann e da miei infruttuosi tentativi di inscatolare le AppImage dei progetti Gambas dentro sandbox con Fairjail


Premessa

Come recita Wikipedia: AppImage è un formato per la distribuzione di software portatile su Linux senza la necessità di autorizzazioni di superutente per installare l'applicazione.
Ha come scopo la distribuzione di software binario indipendente dalla distribuzione Linux.
AppImage consiste quindi in un unico file che contiene in se tutto il necessario per poter eseguire l'applicazione su molte distribuzioni Linux
Per semplificare la lezione il test è stato fatto utilizzando un mio programma (un orologio a cucù) presente sulla Farm e facilmente scaricabile, nulla impedisce di fare la prova su un qualsiasi altro programma.

Alcuni link utili:


Procedimento:

Il giusto Sistema (Ubuntu 20.04.4 LTS)

Al momento per poter creare un AppImage con Gambas dobbiamo farlo da Ubuntu oppure da una sua derivata.
Occorre anche tener conto del fatto che più il sistema operativo (Ubuntu) è vecchio meglio è perché vuol dire che il nostro progetto potrà funzionare su una più ampia gamma di sistemi.
Questo significa anche che viene ribaltata la necessità che il nostro programma debba tener conto delle librerie presenti nella distribuzione come accade per la creazione dei pacchetti di installazione dove è facile che le librerie siano più vecchie di quelle usate dal nostro Gambas.
Infatti useremo sì un sistema “vecchio”, ma con installata l’ultima versione di Gambas che garantirà il buon funzionamento del nostro progetto.
Per ottenere questo, se non stiamo già utilizzando un “vecchio” Ubuntu, dovremo installarlo su una VM (Virtualbox o meglio ancora una QEMU/KVM) oppure creiamo una nuova partizione dove posizionarlo.

Il giusto Gambas

Nel momento in cui aggiorno questa wiki, come detto, Benoit Minisini ha aggiunto la possibilità di firmare la nostra immagine con una chiave GnuPG, questo è possibile solo con la versione Master, ma non passerà molto tempo che la cosa verrà importata nella stabile.
Per controllare la firma di un AppImage basta aprire il terminale nella cartella in cui è presente l’appimage e scrivere:

 ./ <nome dell’appimage> --appimage-signature


 Nota: La possibilità di creare un AppImage con Gambas è presente dalla versione 3.19 pertanto se non siamo interessati alla firma possiamo passare direttamente al capitolo 5.

Creazione di una chiave GnuPG

Se non siamo ancora in possesso di una chiave GnuPG occorre crearla altrimenti possiamo saltare tranquillamente il paragrafo.
Prima di iniziare, il consiglio è di prepararci una passfrase che dovremo inserire in una finestra a un certo punto della procedura.
Non perdiamola perché ci verrà richiesta ogni volta che useremo la chiave.
Apriamo il terminale di Ubuntu 20.04 e scriviamo:

 gpg –full-gen-key

il terminale risponderà:

 gpg (GnuPG) 2.2.19; Copyright (C) 2019 Free Software Foundation, Inc.
 This is free software: you are free to change and redistribute it.
 There is NO WARRANTY, to the extent permitted by law.
 Selezionare il tipo di chiave:
  (1) RSA e RSA (impostazione predefinita)
  (2) DSA ed Elgamal
  (3) DSA (solo firma)
  (4) RSA (solo firma)
  (14) Chiave esistente dalla scheda
 Selezione?

Qui dovremo rispondere 1 come da impostazione predefinita (da notare che tutte le nostre risposte devono rispettare questo stesso criterio).
Proseguiamo con:

 Le chiavi RSA possono essere lunghe tra 1024 e 4096 bit.
 Che chiave vuoi? (3072)

Accettiamo il consiglio e scriviamo 3072

 La dimensione chiave richiesta è 3072 bit
 Specificare la durata di validità della chiave.
      0 = la chiave non scade
     <N>  = la chiave scade dopo N giorni
     <N>w = la chiave scade dopo N settimane
     <N>m = la chiave scade dopo N mesi
     <N>y = la chiave scade dopo N anni
 Per quanto tempo deve essere valida la chiave? (0)

Scriviamo 0

 La chiave non scade affatto
 È corretto? (y/N)

Scriviamo y (yes)

 GnuPG deve costruire un ID utente per identificare la chiave.
 Nome reale: (Qui scriviamo il nostro nome)
 Indirizzo email: (Qui scriviamo la nostra e-mail)
 Commento: (Qui possiamo scrivere un nostro commento)
 È stato selezionato questo USER-ID:
   "nostro-nome (nostro-commento) <nostra@email>"
 Modificare (n)ome, (c)ommento, (e)mail oppure (o)k/(u)scire? (Qui Scriviamo o per ok oppure n se dovete apportare delle modifiche)

A questo punto si apre una finestra in cui dovrete inserire la passfrase che vi siete preparati all’inizio, siate abbastanza veloci nell’inserirla e ripeterla uguale altrimenti occorrerà ripartire da zero.

 È necessario generare molti dati casuali: per fare ciò è utile eseguire
 qualche altra azione (scrivere sulla tastiera, muovere il mouse, usare i
 dischi) durante la generazione dei numeri primi; questo fornisce al
 generatore di numeri casuali migliori possibilità di raccogliere abbastanza
 entropia.

Può essere richiesto di ripetere qualche azione

 gpg: /home/nostro-nome/.gnupg/trustdb.gpg: creato il trustdb
 gpg: chiave XXXXXXXXXX contrassegnata come considerata attendibile
 gpg: directory '/home/nostro-nome/.gnupg/openpgp-revocs.d' creata
 gpg: certificato di revoca archiviato come '/home/nostro-nome/.gnupg/openpgp-revocs.d/CHIAVE ALFANUMERICA.rev'
 chiavi pubbliche e segrete create e firmate.
 pub   rsa3072 2024-06-06 [SC]
      LA CHIAVE ALFANUMERICA DA USARE
 uid                      nome-utente (commento) <indirizzo@mail>
 sub   rsa3072 2024-06-06 [E]

Comandi utili

 ls .gnupg/
 gpg –list-keys (serve a ottenere la chiave alfanumerica da utilizzare per la firma dell’appimage)
 gpg –list-secret-keys
 ./<nome-appimage>.AppImage --appimage-signature

Preparare Ubuntu

Apriamo il terminale e diamo i seguenti comandi, sempre uno per volta:

scarichiamo ricorsivamente da internet Appimage builder:

 wget -O appimage-builder-x86_64.AppImage https://github.com/AppImageCrafters/appimage-builder/releases/download/v1.1.0/appimage-builder-1.1.0-x86_64.AppImage

lo rendiamo eseguibile con:

 chmod +x appimage-builder-x86_64.AppImage

lo spostiamo con:

 sudo mv appimage-builder-x86_64.AppImage /usr/local/bin/appimage-builder

installiamo le librerie per farlo funzionare con:

 sudo apt install -y binutils coreutils desktop-file-utils fakeroot fuse libgdk-pixbuf2.0-dev patchelf python3-pip python3-setuptools squashfs-tools strace util-linux zsync

Fatto, chiudiamo il terminale

Proviamo l’eseguibile

Avviamo la IDE di Gambas.
Dalla Farm installiamo CuckooClock (occorre leggere tutto per attivare il pulsante).
Apriamo il progetto senza avviarlo e dal menu Progetto Compiliamo tutto.
Sempre dalla IDE creiamo un eseguibile lasciandolo all’interno del progetto.
Chiudiamo la IDE e navighiamo all’eseguibile avviandolo con un doppio click.

 Nota: Occorre provare l’eseguibile per vedere se funziona correttamente altrimenti è inutile proseguire e conviene fare la prova con un’altra applicazione funzionante.

Siamo pronti per creare l’Appimage

Riavviamo la IDE di Gambas e apriamo il progetto CuckooClock senza avviarlo.
Dal menu Progetto clicchiamo su Crea un pacchetto di installazione… si aprirà la prima pagina dell’omonima finestra in cui volendo possiamo scrivere la mail, l’indirizzo del nostro sito cambiare il nome ecc.
Il progetto ricreerà l’eseguibile, va bene così.
Clicchiamo sul pulsante >> Seguente e scriviamo qualcosa per il Changelog del tipo: primo test per la creazione di un AppImage
Clicchiamo ancora sul pulsante >> Seguente e spuntiamo la voce AppImage
Clicchiamo ancora sul pulsante >> Seguente

Appimage-builder.jpg

Scegliamo la giusta distribuzione di Ubuntu dalla casella a discesa e clicchiamo sul pulsante Ottiene la configurazione corretta del sistema (Nota: se siamo su una derivata occorre scrivere l’indirizzo del repository di Ubuntu quello della foto va bene oppure uno internazionale come http://archive.ubuntu.com/ubuntu/)
Spuntiamo la casella per l’inserimento della firma e nella casella di testo che si attiva inseriamo la corretta stringa alfanumerica
A questo punto abbiamo immesso tutti i dati utili per la formazione dell’AppImage e possiamo agire sul pulsante Crea il pacchetto ora
Fatto, se tutto è andato bene apparirà la scritta I pacchetti sono stati creati in modo corretto.
Chiudiamo la IDE di Gambas.
Troveremo l’Appimage del programma nella cartella Home per renderlo eseguibile apriamo il terminale e diamo questo comando

 chmod a+x Cuckoo*.AppImage

Controlliamo la firma con

 ./Cuckoo*.AppImage --appimage-signature
 -----BEGIN PGP SIGNATURE-----
 iQGzBAABCgAdFiEEvTStVY3IVP0tTamN9yLiW1YCkIoFAmZhvqwACgkQ9yLiW1YC
 kIoN7wv/cEdn9fXYPOmRzN7w4dIsiNYyW9o22sjA12Wepb+rP2qMuIKUyIpUQLjg
 AhYoGZ3lnHZIZotmz82p0RLZ7jSn5ATuCp8pVtvlOM6fTbAv7qPcWRc3d1VPdeM2
 slGX6cBVfhePCv0lwEw1llkI+cjIKQhccbSoWpZysgrf5/aJeWopExXshTJ2hrnY
 oTLaLWbMrCaArYwXSxdY/McrMAJdL4pmmYo16NxJ6bh8XKV8ppuEhSfCXa4WjP45
 8joaHXzXBO2fQbFs2Q+Wb4AQ5W6kyFJlF2baAKd7R/QV9E+mad3kcUXsJb2/w/If
 ZHJ6Xori1bZmrzUeVO32JZTHs+UYRsm5pbhT8QGJqKZUtsMXmz+3y+aU/sGAPTM6
 Fd7g8MTvteGUHcGyXiObqE26YFze4NmYB017dn5K/+JSUPGaAvb/zY8tVrqJuKkF
 m8PSJ41OKVFNqIhN+GJzd/omYKdbyCdlYY11+oSPX6jpSa5apkqnhncNHA1Z0HRI
 U9JdF+Fj
 =GuvC
 -----END PGP SIGNATURE-----

a questo punto possiamo dare un doppio click per vedere se il programma funziona.

L’Appimage non parte

Se l'Appimage non parte entro pochi secondi occorre provare dal Terminale con il comando:

 ./Cuckoo*.AppImage

in questo modo possiamo vedere la risposta del terminale.
Se il terminale risponde:

 dlopen(): error loading libfuse.so.2
 AppImages require FUSE to run.
 You might still be able to extract the contents of this AppImage
 if you run it with the --appimage-extract option. 
 See https://github.com/AppImage/AppImageKit/wiki/FUSE 
 for more information

Questo normalmente accade su un sistema vergine (senza Gambas installato)
Sebbene molte distribuzioni abbiano una configurazione FUSE funzionante, potrebbe essere necessario installare e configurare FUSE manualmente.
Ad esempio su Ubuntu 22.04 occorre aprire il terminale e digitare:

 sudo add-apt-repository universe

e

 sudo apt install libfuse2


 Attenzione: Per i comandi corretti per la nostra distribuzione fare riferimento alla pagina di aiuto:


https://github.com/AppImage/AppImageKit/wiki/FUSE
come consigliato nella risposta del terminale.

Il link della prova:

https://paste.c-net.org/LuciusCream