configura.sh: una chiave AWS di un altro sul PC non passa piu'

Sul PC di marco.laterza c'era la chiave AWS di fabio.riva: configura.sh la
trovava valida, scriveva "accesso AWS: fabio.riva" e non chiedeva la sua.
Tutto quello che la persona faceva su AWS sarebbe risultato fatto da un
altro.

Adesso Gitea viene prima di AWS, perche' e' lui (con la password) a dire
chi e' la persona. Se la chiave trovata e' di un altro, lo script lo dice,
chiede quella giusta e controlla che lo sia; verifica.sh segna rosso.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

CLAUDE.md

@@ -82,11 +82,17 @@ token, push), spiegala in una riga la prima volta.
      **Lasciare aperta la pagina**: la chiave segreta si vede una volta sola.
    - **Gitea** (`https://git.oto-farm.com`): entrare con la password provvisoria
      e sceglierne una nuova. Nient'altro: il token lo crea lo script.
-4. **`./configura.sh`**, nel terminale della persona. Chiede i due pezzi della
+4. **`./configura.sh`**, nel terminale della persona. Chiede utente e
-   chiave AWS e utente e password di Gitea; crea l'accesso a Gitea, configura
+   password di Gitea e poi i due pezzi della chiave AWS; crea l'accesso a
-   git, genera la chiave SSH e la carica sul suo profilo Gitea (da lì la
+   Gitea, configura git, genera la chiave SSH e la carica sul suo profilo
-   prende l'amministratore: **non va mandata a nessuno**), scrive i nomi dei
+   Gitea (da lì la prende l'amministratore: **non va mandata a nessuno**),
-   server in `~/.ssh/config`. Poi fa chiudere la pagina di AWS.
+   scrive i nomi dei server in `~/.ssh/config`. Poi fa chiudere la pagina di
+   AWS. Gitea viene prima apposta: è lui a dire chi è la persona. Se sul PC
+   c'è già una chiave AWS **di un altro** (rimasta da chi lo usava, o copiata
+   da un collega), lo script lo dice e chiede la sua: dille di avvisare
+   l'amministratore, perché quella chiave va disattivata. Una chiave altrui
+   non va mai tenuta "intanto che funziona": tutto quello che la persona fa
+   su AWS risulterebbe fatto dall'altro.
 5. **VPN** (solo chi sviluppa): installare il client e importare il file
    arrivato dal fornitore.
 6. **Dirlo all'amministratore**: «ho finito la configurazione». È il segnale

configura.sh

@@ -1,10 +1,10 @@
 #!/bin/bash
 #
-# PREPARA IL PC: accesso AWS, accesso Gitea, git, chiave SSH, nomi dei server.
+# PREPARA IL PC: accesso Gitea, accesso AWS, git, chiave SSH, nomi dei server.
 #
 #   ./configura.sh
 #
-# Si lancia nel proprio terminale: chiede le chiavi AWS e la password Gitea
+# Si lancia nel proprio terminale: chiede la password Gitea e le chiavi AWS
 # con l'input nascosto, e un assistente AI non puo' rispondere al posto tuo.
 # Si puo' rilanciare: quello che e' gia' a posto non viene toccato.
 # Non crea accessi: quelli li crea un amministratore, qui si usano.
@@ -14,36 +14,7 @@ cd "$(dirname "$0")" || exit 1
 . ./comune.sh
 
 # --------------------------------------------------------------------------
-titolo "1. AWS"
+titolo "1. Gitea"
-# --------------------------------------------------------------------------
-# La chiave di accesso la crea la persona dalla console (Security
-# credentials → Create access key): qui la si incolla una volta e finisce in
-# ~/.aws/credentials, dove la leggono la AWS CLI e gli script dei progetti.
-if ! c_e aws ; then
-  male "AWS CLI non installata: installala e rilancia questo script."
-elif IDENTITA="$(aws sts get-caller-identity --query Arn --output text 2> /dev/null)" ; then
-  ok "accesso AWS: ${IDENTITA##*/}"
-else
-  echo "  Serve la tua chiave di accesso AWS, due pezzi. La crei nella console AWS:"
-  echo "  il tuo nome in alto a destra → Security credentials → Create access key (uso: CLI)."
-  echo "  Non si vede mentre la incolli, ed e' normale."
-  read -r -s -p "  Access key ID (inizia con AKIA): " CHIAVE_ID ; echo
-  read -r -s -p "  Secret access key: " CHIAVE_SEGRETA ; echo
-  CHIAVE_ID="$(printf '%s' "$CHIAVE_ID" | tr -d '[:space:]')"
-  CHIAVE_SEGRETA="$(printf '%s' "$CHIAVE_SEGRETA" | tr -d '[:space:]')"
-  aws configure set aws_access_key_id "$CHIAVE_ID"
-  aws configure set aws_secret_access_key "$CHIAVE_SEGRETA"
-  aws configure set region "$AWS_REGIONE"
-  unset CHIAVE_SEGRETA
-  if IDENTITA="$(aws sts get-caller-identity --query Arn --output text 2> /dev/null)" ; then
-    ok "accesso AWS: ${IDENTITA##*/}"
-  else
-    male "AWS non accetta questa chiave: controlla di aver copiato i due pezzi interi, o creane un'altra."
-  fi
-fi
-
-# --------------------------------------------------------------------------
-titolo "2. Gitea"
 # --------------------------------------------------------------------------
 # Alla persona si chiede la password, non un token: il token lo crea lo
 # script con l'API di Gitea, cosi' non c'e' da cercarlo fra le impostazioni.
@@ -99,6 +70,57 @@ if [ -n "$UTENTE" ] ; then
   ok "git configurato ($(git config --global user.name) <$(git config --global user.email)>)"
 fi
 
+# --------------------------------------------------------------------------
+titolo "2. AWS"
+# --------------------------------------------------------------------------
+# La chiave di accesso la crea la persona dalla console (Security
+# credentials → Create access key): qui la si incolla una volta e finisce in
+# ~/.aws/credentials, dove la leggono la AWS CLI e gli script dei progetti.
+#
+# Viene dopo Gitea apposta: e' Gitea, con la password, a dire chi e' la
+# persona. Una chiave gia' presente sul PC non basta a dirlo: puo' essere
+# rimasta da chi lo usava prima, o copiata da un collega, e allora tutto
+# quello che la persona fa su AWS risulterebbe fatto da un altro.
+chiedi_chiave_aws () {
+  echo "  Serve la tua chiave di accesso AWS, due pezzi. La crei nella console AWS:"
+  echo "  il tuo nome in alto a destra → Security credentials → Create access key (uso: CLI)."
+  echo "  Non si vede mentre la incolli, ed e' normale."
+  read -r -s -p "  Access key ID (inizia con AKIA): " CHIAVE_ID ; echo
+  read -r -s -p "  Secret access key: " CHIAVE_SEGRETA ; echo
+  CHIAVE_ID="$(printf '%s' "$CHIAVE_ID" | tr -d '[:space:]')"
+  CHIAVE_SEGRETA="$(printf '%s' "$CHIAVE_SEGRETA" | tr -d '[:space:]')"
+  if [ -z "$CHIAVE_ID" ] || [ -z "$CHIAVE_SEGRETA" ] ; then
+    male "chiave non inserita: rilancia quando ce l'hai." ; unset CHIAVE_SEGRETA ; return 1
+  fi
+  aws configure set aws_access_key_id "$CHIAVE_ID"
+  aws configure set aws_secret_access_key "$CHIAVE_SEGRETA"
+  aws configure set region "$AWS_REGIONE"
+  unset CHIAVE_SEGRETA
+  if ! IDENTITA="$(aws sts get-caller-identity --query Arn --output text 2> /dev/null)" ; then
+    male "AWS non accetta questa chiave: controlla di aver copiato i due pezzi interi, o creane un'altra."
+  elif [ -n "$UTENTE" ] && [ "${IDENTITA##*/}" != "$UTENTE" ] ; then
+    male "questa chiave e' di ${IDENTITA##*/}, non tua ($UTENTE): crea la tua dalla console AWS, entrando col tuo utente, e rilancia."
+  else
+    ok "accesso AWS: ${IDENTITA##*/}"
+  fi
+}
+
+if ! c_e aws ; then
+  male "AWS CLI non installata: installala e rilancia questo script."
+elif IDENTITA="$(aws sts get-caller-identity --query Arn --output text 2> /dev/null)" ; then
+  if [ -z "$UTENTE" ] || [ "${IDENTITA##*/}" = "$UTENTE" ] ; then
+    ok "accesso AWS: ${IDENTITA##*/}"
+  else
+    attento "su questo PC c'e' gia' una chiave AWS, ma e' di ${IDENTITA##*/}, non tua ($UTENTE)."
+    echo "  Usandola, tutto quello che fai su AWS risulterebbe fatto da ${IDENTITA##*/}."
+    echo "  La sostituisco con la tua. Avvisa l'amministratore: quella chiave e' uscita"
+    echo "  dal PC di ${IDENTITA##*/} e va disattivata."
+    chiedi_chiave_aws
+  fi
+else
+  chiedi_chiave_aws
+fi
+
 # --------------------------------------------------------------------------
 titolo "3. Chiave SSH"
 # --------------------------------------------------------------------------

verifica.sh

@@ -25,8 +25,15 @@ fi
 if c_e claude ; then ok "Claude Code" ; else attento "Claude Code non installato (non obbligatorio, ma ti guida)" ; fi
 
 titolo "AWS"
+# Chi e' la persona lo dice Gitea: una chiave AWS di un altro sul PC vuol dire
+# che tutto quello che fa su AWS risulta fatto da lui.
+UTENTE="$(utente_gitea)"
 if c_e aws && IDENTITA="$(aws sts get-caller-identity --query Arn --output text 2> /dev/null)" ; then
-  ok "accesso: ${IDENTITA##*/}"
+  if [ -n "$UTENTE" ] && [ "${IDENTITA##*/}" != "$UTENTE" ] ; then
+    rosso "la chiave AWS di questo PC e' di ${IDENTITA##*/}, non tua ($UTENTE): rilancia ./configura.sh, che la sostituisce"
+  else
+    ok "accesso: ${IDENTITA##*/}"
+  fi
   if aws ssm get-parameter --region "$AWS_REGIONE" --name "$SSM_PROVA" --query Parameter.Name --output text > /dev/null 2>&1 ; then
     ok "legge i segreti comuni su SSM"
   else
@@ -37,7 +44,6 @@ else
 fi
 
 titolo "Gitea"
-UTENTE="$(utente_gitea)"
 if [ -n "$UTENTE" ] ; then
   ok "token valido (utente $UTENTE)"
   if grep -q "@$GITEA_HOST" "$HOME/.git-credentials" 2> /dev/null || [ -n "$(git config --global credential.helper)" ] ; then