Certera.io notification via Slack webhook on Rocketchat

Certera is a software that allows you, as sysadmin, to centralize the production and the distribution of SSL certificates for your websites and applications.

If you landed here it’s because you probably need to go deeper on some topic as notifications from Certera when something is going wrong or, more often, when a certificate is about to expire.

An easy and effective way to get notifications from Certera is on your Slack chat with a webhook, but what happen if you or your company are using Rocket Chat as instant messaging system?

I personally opened a ticket (feature request) to Certera developers (that are very reactive) in which I asked for a RocketChat integration for Certera.io.

I’m sure they will solve it soon, but meanwhile I will give you some hint to make the things done with the Slack Webhook, in order to translate the request from Slack to RocketChat.

Let’s begin then.

Step1 – Create a Rocketchat webhook

  • Go to Admin panel -> Integration
  • Create an Incoming Webhook dedicated to certera
  • Configure it
  • Activate the script and put there the following code (gotten in Rocket Chat Integrations page)
/* exported Script */
/* globals console, _, s */

/** Global Helpers
 *
 * console - A normal console instance
 * _       - An underscore instance
 * s       - An underscore string instance
 */

class Script {
  /**
   * @params {object} request
   */
  process_incoming_request({ request }) {
    // request.url.hash
    // request.url.search
    // request.url.query
    // request.url.pathname
    // request.url.path
    // request.url_raw
    // request.url_params
    // request.headers
    // request.user._id
    // request.user.name
    // request.user.username
    // request.content_raw
    // request.content

    // console is a global helper to improve debug
    console.log(request);

    return {
      content:{
        text: request.content.blocks[0].text.text + "\n" +  request.content.blocks[1].text.text
        // "attachments": [{
        //   "color": "#FF0000",
        //   "author_name": "Rocket.Cat",
        //   "author_link": "https://open.rocket.chat/direct/rocket.cat",
        //   "author_icon": "https://open.rocket.chat/avatar/rocket.cat.jpg",
        //   "title": "Rocket.Chat",
        //   "title_link": "https://rocket.chat",
        //   "text": "Rocket.Chat, the best open source chat",
        //   "fields": [{
        //     "title": "Priority",
        //     "value": "High",
        //     "short": false
        //   }],
        //   "image_url": "https://rocket.chat/images/mockup.png",
        //   "thumb_url": "https://rocket.chat/images/mockup.png"
        // }]
       }
    };

    // return {
    //   error: {
    //     success: false,
    //     message: 'Error example'
    //   }
    // };
  }
}

Configure and activate everything.

Step2 – Put the webhook url to Certera.io admin web panel

In Certera.io notification page you will find the Slack webhook URL, put what you have produced on Rocketchat side and activate the notification.

Done!

Explaination

You have certainly noticed that the most of the source code is commented (//), infact the most important part of the code is:

        text: request.content.blocks[0].text.text + "\n" +  request.content.blocks[1].text.text

This code translates the payload of the POST request gotten via webhook by Rocket Chat.

The “translation” is done according to the template I found in Certera.io source code.

Dump database Mysql/Maria DB in file separati

Come eseguire un export su file di tutti i database su un server Mysql da riga di comando.

Avevamo già parlato di come effettuare il backup di tutti i database mysql per mezzo di uno script bash, ma di recente un mio collega mi ha segnalato una soluzione, che secondo me è molto più elegante.

Si tratta di un singolo comando da eseguire sulla linea di comando con i pipe (questo è il pipe “|”).

Ecco il comando:

mysql -N -e 'show databases' | while read dbname; do mysqldump --complete-insert --routines --triggers --single-transaction "$dbname" > "$dbname".sql; [[ $? -eq 0 ]] && gzip "$dbname".sql; done 

Vediamo i comandi nel dettaglio; per farlo scriviamo sulla cli quanto segue:

mysql --help

-N, –skip-column-names
Don’t write column names in results.

L’opzione -N non fornisce in output il nome della colonna, nel nostro caso la lista dei database sarà quindi priva di intestazione ed utilizzabile nel while successivo al primo pipe.

-e, –execute=name Execute command and quit. (Disables –force and history
file.)

L’opzione -e, consente di eseguire il comando tra apici, ovvero “‘show databases'”.

La parte che segue il pipe (“|”) prende come input l’output di quello che lo precede, consentendo di effettuare un ciclo while sul nome di ogni database e di fare un dump con il comando mysqldump.

Forse si può fare meglio, ma il kata-programming non va abusato e chi si accontenta gode!

Detto questo se vi mettete a smanettare con quello script, postate tutto nei commenti.

Creazione e rinnovo certificato SSL Letsencrypt con Certbot e Docker e caricamento su AWS ACM

Prerequisiti

  1. Docker installato sul sistema
  2. AWS cli installata e configurata
  3. Utente AWS cli con permessi IAM di gestione di DNS Route53

Il problema

In breve:

Vogliamo creare un certificato SSL autofirmato e caricarlo su AWS ACM.

In dettaglio:

Vogliamo utilizzare un certbot dockerizzato che ci consenta di usare letsencrypt, per creare un certificato SSL.

Il metodo di validazione (la challenge) del dominio che abbiamo scelto è la dns-challenge, che consiste nel creare uno o più record DNS nella zona del dominio.
La validazione è uno step indispensabile per consentire a letsencrypt e in generale all’ente certificatore, di certificare che si è proprietari di un determinato dominio.

Su AWS il servizio che si occupa di gestire le zone DNS è Route-53 (per gli amici R53), dove possiamo gestire tutti i record DNS della propria zona.

Il certbot dockerizzato sfrutta un plugin chiamato dns-route53 (certbot/dns-route53) che si collega direttamente a Route-53 e si occupa della validazione, cosa di cui quindi non dovremo preoccuparci.

L’unica cosa che è necessaria per poter usare i comandi è un utente IAM (di AWS) con i privilegi di gestione dei DNS su R-53, che ci consenta di automatizzare il processo di verifica.
Un utente IAM AWS, può disporre di accesso cli (in questo caso è obbligatorio), per il quale occorre ACCESS_KEY_ID e AWS_SECRET_ACCESS_KEY.

L’esempio che ho effettuato, è stato testato usando un utente IAM admin di R53, con in pratica deve avere tutti i permessi per la gestione delle rotte e delle zone dns. Tuttavia per le tue esigenze reali, potresti aver bisogno di permessi più circoscritti e con un livello di granularità maggiore (ad esempio limitando la cosa solo a determinate zone DNS).

La Soluzione

Questo comando, consente la creazione di un certificato SSL con letsencrypt, con verifica automatica del dominio. Se tutto va a buon fine esso produrrà sotto la cartella /etc/letsencrypt i certificati in formato pem.

Ecco il comando:

docker run --rm -it --env AWS_ACCESS_KEY_ID=YOUR_AWS_ACCESS_KEY_ID --env AWS_SECRET_ACCESS_KEY=YOUR_AWS_SECRET_ACCESS_KEY -v "/etc/letsencrypt:/etc/letsencrypt" certbot/dns-route53 certonly --dns-route53 -d mydomain.com --agree-tos --email myemail@mydomain.com

NOTA: Ripetere il comando si tradurrà in aggiornare i file che compongono il certificato, che in ogni caso scadrà dopo un massimo di 3 mesi.

Per chiarezza è bene tenere presente che la parte

-v "/etc/letsencrypt:/etc/letsencrypt"

rappresenta un volume, concretamente è il mapping tra la cartella letsencrypt nel container e quella fuori (quella di sistema), per consentire la persistenza dei dati prodotti (i certificati) anche fuori dal container.

Per verificare che tutto sia andato a buon fine potete visitare la cartella

/etc/letsencrypt/live/mydomain.com

e controllare che tutti i certificati siano stati creati.

Normalmente i file sono:

  • cert.pem
  • chain.pem
  • fullchain.pem
  • privkey.pem

Per verificare la data di scadenza di un certificato puoi usare il openssl, come ho spiegato in questo articolo.

Caricare il certificato su AWS ACM

Una volta che è stato correttamente generato, il certificato può essere caricato tramite pannello web di AWS ACM, o via CLI.
Per caricare il certificato via CLI, è necessario avere installato sul proprio sistema la console di AWS e aver definito le credenziali di accesso, cosa che normalmente si trova nel file ~/.aws/credential.

Il comando che segue consente di effettuare l’upload del certificato (ovvero dei file che lo compongono) su AWS ACM:

aws acm import-certificate --certificate fileb:///etc/letsencrypt/live/mydomain.com/cert.pem --private-key fileb:///etc/letsencrypt/live/mydomain.com/privkey.pem --certificate-chain fileb:///etc/letsencrypt/live/mydomain.com/fullchain.pem

In risposta si otterrà qualcosa di questo tipo:

{
"CertificateArn": "arn:aws:acm:eu-central-1:*******:certificate/**********"
}

In questo caso la zona del certificato è “eu-central-1” (Francoforte) e, anche se è ovvio, al posto degli asterischi ci sono dei numeri.

Per l’update del certificato, invece, va utilizzato un comando leggermente diverso, questo:

aws acm get-certificate --certificate-arn arn:aws:acm:eu-central-1:*********:certificate/****************

L’ARN è un identificativo univoco di una risorsa su AWS, anche il certificato SSL su ACM ha un ARN che può essere letto da pannello web, oppure direttamente dalla risposta avuta in fase di primo caricamento.

Spero di essere stato utile con questo articolo liberamente ispirato all’esempio proposto su coderevolve, preso a riferimento.

Tilde e backtick su windows

I sistemisti linux (quindi la quasi totalità della categoria), quando costretti ad usare Windows, non possono di certo fare a meno della linux shell, che in ambiente Windows, viene emulata in maniera tuttosommato soddisfacente, da programmi come cygwin e git bash.

Tuttavia la shell di linux, non è l’unica cosa che manca ad un pinguinofilo, quando è costretto ad usare il sistema operativo di Microsoft. Uno degli aspetti più avvilenti tante volte è rappresentato dalla tastiera ed in particolare di alcuni tasti che si comportano in maniera differente sui due sistemi operativi.

Questo breve post offre una panoramica e una soluzione al problema.

Tilde ~

Il carattere tilde è molto usato in ambiente linux, dove basta pigiare

Alt Gr + ì

per ottenerla.

Su ambiente windows invece si deve fare ricorso al tastierino numerico per ottenere lo stesso risultato, in particolare bisogna digitare la sequenza

Alt + 126

per vedere stampato a video il carattere tilde.

Backtick `

Per quanto riguarda il carattere backtick, questo `, su ambiente linux sarà sufficiente digitare ? tendendo premuto il tasto Alt Gr, ovvero:

Alt Gr + ?

Su sistema operativo Windows invece, bisognerà ricorrere al tastierino numerico, digitando:

Alt + 96

Ma, io non ho il tastierino numerico!

È abbastanza frustrante dover risolvere questo problema quando non sia ha un tastierino numerico sulla tastiera, perché ad esempio si sta utilizzando un PC portatile.

Se dunque hai un notebook con Windows e vuoi scrivere tilde o backtick, non ti resta che dare un’occhiata alla pagina “layout.ahk” del Github di Federico Carboni, dove viene mostrato l’uso del software AutoHotKey che risolve in maniera molto elegante il problema del tilde o del backtick su Windows.

Nella stessa pagina, viene mostrato un altro software Microsoft Keyboard Layout Creator, che assolve allo stesso scopo, ma che ho trovato meno pratico di AutoHotKey, che mi è sembrato più immediato.

Buona digitazione a tutti.

Come controllare la scadenza di un certificato SSL da console con Ubuntu

Talvolta verificare quale sia la data di scadenza di un certificato crt o pem, presente sul proprio filesystem, specie se la macchina dove si trova tale certificato, non è esposta su internet o semplicemente il certificato non è visualizzabile per mezzo di un web browser, come nel caso dei certificati SSL per i siti web.

Pertanto, entriamo subito nel vivo e vediamo come fare per ottenere l’expiration date del certificato SSL.

Leggere la data di scadenza di un certificato SSL con estensione pem o con estensione crt, eseguendo un comando direttamente da terminale su OS Linux Ubuntu.

È possibile controllare quando scade la validità di un certificato SSL (di tipo pem o di tipo crt) eseguendo un semplice comando dalla console di Ubuntu (da bash nel terminale).

Per farlo possiamo usare i comandi forniti da OpenSSL.

cat /path/to/my/cert/certificate.crt | openssl x509 -noout -enddate

Ovviamente dopo il comando “cat”, che stampa il testo del certificato, ci deve essere il path completo del certificato, sostituire quello fornito in esempio.

Si dovrebbe ottenere in uscita un testo simile a questo:

notAfter=Jul 17 08:01:33 2021 GMT

Dove è riportata la data dopo la quale il certificato viene considerato scaduto.