Rete bassa

interroga_dns(nome, tipo = "A", server = nulla, porta = 53)#

Chiede al DNS i record di un nome.

tipo può essere "A", "AAAA", "MX", "TXT", "NS", "CNAME", "SOA", "PTR". Con server = nulla usa il server DNS di questo computer. Restituisce una lista di dizionari con "tipo", "nome", "ttl" e "valore" (per MX e SOA il valore è a sua volta un dizionario). È una normale interrogazione di sola lettura.

per ogni r in interroga_dns("esempio.it", "MX") fai stampa(r["valore"]) fine

dns_a(nome, server = nulla)#

Gli indirizzi IPv4 (record A) di un nome, come lista di testi.

per ogni ip in dns_a("esempio.it") fai stampa(ip) fine

dns_aaaa(nome, server = nulla)#

Gli indirizzi IPv6 (record AAAA) di un nome, come lista di testi.

stampa(dns_aaaa("esempio.it"))

dns_mx(nome, server = nulla)#

I server di posta (record MX), ordinati per priorità.

Ogni elemento è un dizionario con "priorita" (più basso = prima scelta) e "server".

stampa(dns_mx("esempio.it")[0]["server"])

dns_txt(nome, server = nulla)#

I record TXT di un nome (per esempio SPF o verifiche), come lista di testi.

per ogni t in dns_txt("esempio.it") fai stampa(t) fine

dns_ns(nome, server = nulla)#

I server DNS autorevoli (record NS) di un dominio, come lista di testi.

stampa(dns_ns("esempio.it"))

dns_cname(nome, server = nulla)#

Il nome "vero" a cui punta un alias (record CNAME), o nulla.

stampa(dns_cname("www.esempio.it"))

dns_soa(nome, server = nulla)#

I dati "SOA" di un dominio (chi lo gestisce, ogni quanto si aggiorna).

Restituisce un dizionario con "server_principale", "responsabile", "serie", "aggiornamento", "riprova", "scadenza", "minimo", oppure nulla.

stampa(dns_soa("esempio.it")["server_principale"])

dns_ptr(indirizzo, server = nulla)#

I nomi associati a un indirizzo IP (record PTR, DNS inverso).

stampa(dns_ptr("8.8.8.8"))

dns_inverso(indirizzo, server = nulla)#

Il nome del computer che ha quell'indirizzo IP, o nulla.

È il "DNS inverso": da un indirizzo risale al nome, chiedendo il record PTR al DNS.

stampa(dns_inverso("8.8.8.8"))

server_dns_sistema()#

La lista dei server DNS che questo computer usa per cercare i nomi.

stampa(server_dns_sistema())

indirizzo_pubblico_dns(server = nulla)#

Il tuo indirizzo IP pubblico, chiesto via DNS a un resolver.

Chiede "myip.opendns.com" a un resolver di OpenDNS (che risponde con l'indirizzo da cui arrivi): è un modo leggero e difensivo per scoprire con che indirizzo ti vede Internet. Con server puoi indicare un altro resolver. Restituisce un testo, o nulla se non arriva risposta.

stampa(indirizzo_pubblico_dns())

certificato_completo(sito, porta = 443)#

Tutto quello che si può leggere del certificato di un sito.

Oltre a quello di certificato_sito (soggetto, emittente, date, validità) aggiunge "algoritmo_firma", "algoritmo_chiave", "bit_chiave", "numero_serie", "impronta_sha256", "versione_tls", "cifrario", "debole" (vero se usa algoritmi o chiavi deboli) e "avvisi" (lista di problemi in parole). Utile per controllare la salute dei TUOI servizi.

stampa(certificato_completo("www.miosito.it")["avvisi"])

catena_certificati(sito, porta = 443)#

I certificati che il sito presenta, dal suo a quelli che lo firmano.

Restituisce una lista di dizionari (soggetto, emittente, scadenza, algoritmi). Nota: con Python 3.11 (come nell'app Android) il sistema dà solo il certificato del sito; per vedere tutta la catena di un TUO servizio leggi il file del certificato con controlla_catena_file("fullchain.pem").

stampa(catena_certificati("www.esempio.it")[0]["emittente"])

algoritmi_certificato(sito, porta = 443)#

Gli algoritmi di sicurezza usati dal certificato di un sito.

Restituisce un dizionario con "firma", "chiave", "bit", "versione_tls", "cifrario", "debole".

stampa(algoritmi_certificato("www.esempio.it")["firma"])

impronta_certificato(sito, porta = 443, algoritmo = "sha256")#

L'impronta (fingerprint) del certificato.

Serve a riconoscere un certificato in modo sicuro. algoritmo può essere "sha256" (consigliato), "sha1" o "md5" (questi due sono deboli: solo per confronti con sistemi vecchi).

stampa(impronta_certificato("www.esempio.it"))

avvisi_certificato(sito, porta = 443)#

La lista dei problemi del certificato di un sito (vuota se sta bene).

Avvisa se è scaduto o sta per scadere, se usa algoritmi o chiavi deboli, se la versione di TLS è vecchia.

se avvisi_certificato("www.miosito.it") == [] allora stampa("Tutto a posto") fine

verifica_certificato_sito(sito, porta = 443)#

Controlla che il certificato di un sito sia valido e fidato.

Verifica davvero la catena di fiducia (come fa il browser): nome giusto, emittente riconosciuto, non scaduto. Restituisce un dizionario con "valido" (vero/falso), "problema" (in parole, o nulla), "scaduto", "giorni_rimasti".

se non verifica_certificato_sito("www.miosito.it")["valido"] allora stampa("Attenzione!") fine

certificato_da_file(percorso)#

Legge un certificato salvato in un file (.pem o .der) e lo analizza.

Comodo per controllare il certificato di un TUO servizio senza collegarti. Restituisce lo stesso tipo di dizionario di certificato_completo (soggetto, emittente, date, algoritmi, impronta, "debole", "avvisi").

stampa(certificato_da_file("certificato.pem")["scadenza"])

controlla_catena_file(percorso)#

Controlla una catena di certificati salvata in un file PEM.

Legge tutti i certificati del file (per

stampa(controlla_catena_file("fullchain.pem")["problemi"])

indirizzo_locale()#

L'indirizzo IP di questo computer nella rete di casa (per esempio "192.168.1.23").

È l'indirizzo con cui ti vedono gli altri computer della tua rete.

stampa(indirizzo_locale())

indirizzi_locali()#

Tutti gli indirizzi IP di questo computer (lista di dizionari).

Ogni elemento ha "indirizzo", "versione" (4 o 6), "tipo" (in parole: "questo computer", "privato"...).

per ogni a in indirizzi_locali() fai stampa(a["indirizzo"], a["tipo"]) fine

interfacce_rete()#

Le schede di rete di questo computer con i loro indirizzi (lista di dizionari).

Ogni elemento ha "nome", "indirizzi" (lista di {"indirizzo", "versione"}), "mac" e "attiva". I dettagli completi (indirizzi, MAC, stato) sono disponibili su Linux e Android; su Windows e macOS si ottengono i nomi delle schede e gli indirizzi principali del computer.

per ogni i in interfacce_rete() fai stampa(i["nome"], i["indirizzi"]) fine

connessioni_aperte()#

Le connessioni di rete aperte da questo computer e quali programmi le usano.

Restituisce una lista di dizionari con "protocollo" (TCP/UDP), "locale_indirizzo", "locale_porta", "remoto_indirizzo", "remoto_porta", "stato", "pid" e "programma" (il nome del programma, dove si può sapere). Il nome del programma e il PID sono disponibili su Linux e Android; su Windows c'è il PID; su macOS di norma solo gli indirizzi. Serve a capire chi sta parlando con la rete dal TUO computer.

per ogni c in connessioni_aperte() fai stampa(c["programma"], c["remoto_indirizzo"]) fine

tabella_routing()#

La tabella di instradamento di questo computer (dove manda i pacchetti).

Restituisce una lista di dizionari con "destinazione", "prefisso", "gateway", "interfaccia", "metrica", "versione" e "predefinita" (vero per la rotta di default verso Internet).

per ogni r in tabella_routing() fai stampa(r["destinazione"], "->", r["gateway"]) fine

gateway_predefinito()#

L'indirizzo del router che porta a Internet (il "gateway"), o nulla.

stampa(gateway_predefinito())

apri_cattura(percorso)#

Apre una cattura di rete (.pcap o .pcapng) in sola lettura e la analizza.

Restituisce un oggetto cattura con quanti, formato, durata e i metodi pacchetti(), pacchetto(n), riassunto(), conversazioni(), flussi_tcp(), protocolli(), top_parlatori(), porte_piu_usate(), filtra(...), dns(), payload(n). Legge soltanto: non manda niente in rete.

variabile c = apri_cattura("traffico.pcap")stampa(c.riassunto())

riassunto_cattura(cattura)#

Un riassunto della cattura (come cattura.riassunto()), in forma di funzione.

variabile c = apri_cattura("prova.pcap")stampa(riassunto_cattura(c))

estrai_payload(cattura, numero)#

I dati trasportati dal pacchetto numero (come cattura.payload(n)).

stampa(estrai_payload(c, 4))

genera_cattura_prova(percorso)#

Scrive un piccolo file .pcap di esempio (per imparare e per i test).

Crea un file .pcap con alcuni pacchetti finti (una pagina web via TCP, una domanda DNS, un ping ICMP). SCRIVE SOLO UN FILE sul disco: non manda e non inietta niente in rete. Poi lo puoi aprire con apri_cattura(percorso). Restituisce un dizionario con "file" e "pacchetti".

genera_cattura_prova("prova.pcap")stampa(apri_cattura("prova.pcap").riassunto())

.conversazioni()#

Chi parla con chi (coppie di indirizzi IP), con pacchetti e byte.

Restituisce una lista di dizionari con "a", "b", "pacchetti", "byte", ordinata dai più attivi.

per ogni v in c.conversazioni() fai stampa(v["a"], "<->", v["b"], v["pacchetti"]) fine

.dns()#

Tutte le domande e risposte DNS trovate nella cattura.

Restituisce una lista di dizionari con "numero" (del pacchetto), "risposta" (vero/falso), "nome", "tipo", "domande", "risposte".

per ogni d in c.dns() fai stampa(d["nome"], d["tipo"]) fine

.filtra(ip = nulla, porta = nulla, protocollo = nulla)#

I pacchetti che rispettano i filtri.

Puoi filtrare per indirizzo ip (sorgente o destinazione), per porta o per protocollo (per

pacchetti()per ogni p in c.filtra(protocollo = "DNS") fai stampa(p["info"]) fine

.flussi_tcp()#

I flussi TCP ricostruiti (una "conversazione" TCP per ogni coppia di porte).

Ogni flusso è un dizionario con "da", "a" (indirizzo:porta), "pacchetti", "byte", "apertura" (vero se c'è il SYN), "chiusura" (vero se c'è il FIN), "dati_cliente" e "dati_server" (i byte trasportati nelle due direzioni, rimessi in ordine alla meglio).

per ogni f in c.flussi_tcp() fai stampa(f["da"], "->", f["a"], f["byte"]) fine

.pacchetti(da = 1, quanti = 100)#

La lista dei pacchetti (dal numero da, al massimo quanti).

Ogni pacchetto è un dizionario con "numero", "tempo", "secondi", "protocollo", "sorgente", "destinazione", "porta_sorgente", "porta_destinazione", "flag", "lunghezza", "info".

per ogni p in c.pacchetti(1, 20) fai stampa(p["info"]) fine

.pacchetto(numero)#

Il pacchetto numero numero (il primo è 1), come dizionario.

stampa(c.pacchetto(1)["info"])

.payload(numero)#

I dati trasportati dal pacchetto (il "contenuto"), come dati_binari.

È quello che sta dentro TCP o UDP, senza le intestazioni. Sui dati puoi usare .in_testo(), .codifica(), .in_lista(), .salva(...).

stampa(c.payload(4).in_testo())

.porte_piu_usate(quanti = 10)#

Le porte più usate nella cattura.

Restituisce una lista di dizionari con "porta", "protocollo", "pacchetti".

stampa(c.porte_piu_usate())

.protocolli()#

Quante volte compare ogni protocollo (dizionario protocollo -> numero).

stampa(c.protocolli())

.riassunto()#

Un riassunto della cattura (pacchetti, byte, durata, protocolli, chi parla...).

Restituisce un dizionario con "pacchetti", "byte", "durata", "protocolli", "conversazioni" (quante), "flussi_tcp" (quanti), "top_parlatori" (i primi 5), "porte_piu_usate" (le prime 5).

stampa(c.riassunto()["protocolli"])

.top_parlatori(quanti = 10)#

Gli indirizzi IP più attivi (per numero di pacchetti).

Restituisce una lista di dizionari con "indirizzo", "pacchetti", "byte".

stampa(c.top_parlatori(5))