Typosquatting generator

From Wikipedia: “Typosquatting, also called URL hijacking, a sting site, or a fake URL, is a form of cybersquatting, and possibly brandjacking which relies on mistakes such as typos made by Internet users when inputting a website address into a web browser. Should a user accidentally enter an incorrect website address, they may be led to any URL (including an alternative website owned by a cybersquatter).”

This C# code allow you to create a list of typos starting from a string. 

using System;
using System.Collections.Generic;
using System.Linq;

namespace TypoSample
{
    class Program
    {
        static void Main(string[] args)
        {
            List<string> strings = new Typo().GetList("emiliano");

            foreach (string s in strings)
            {
                Console.WriteLine(s);
            }
        }
    }

    internal class Typo
    {
        private static List<Character> characters = new List<Character>()
        {
            new Character() { Value = 'a', Similar = new List<char>() { '4' } },
            new Character() { Value = 'b', Similar = new List<char>() { } },
            new Character() { Value = 'c', Similar = new List<char>() {  } },
            new Character() { Value = 'd', Similar = new List<char>() {  } },
            new Character() { Value = 'e', Similar = new List<char>() { '3' } },
            new Character() { Value = 'f', Similar = new List<char>() {  } },
            new Character() { Value = 'g', Similar = new List<char>() { '6' } },
            new Character() { Value = 'h', Similar = new List<char>() { } },
            new Character() { Value = 'i', Similar = new List<char>() { '1', 'l' } },
            new Character() { Value = 'j', Similar = new List<char>() { } },
            new Character() { Value = 'k', Similar = new List<char>() { } },
            new Character() { Value = 'l', Similar = new List<char>() { '1', 'i' } },
            new Character() { Value = 'm', Similar = new List<char>() { 'n' } },
            new Character() { Value = 'n', Similar = new List<char>() { 'm' } },
            new Character() { Value = 'o', Similar = new List<char>() { '0' } },
            new Character() { Value = 'p', Similar = new List<char>() { 'q' } },
            new Character() { Value = 'q', Similar = new List<char>() { 'p' } },
            new Character() { Value = 'r', Similar = new List<char>() {  } },
            new Character() { Value = 's', Similar = new List<char>() { '5' } },
            new Character() { Value = 't', Similar = new List<char>() { 'f' } },
            new Character() { Value = 'u', Similar = new List<char>() { 'v' } },
            new Character() { Value = 'v', Similar = new List<char>() { 'u' } },
            new Character() { Value = 'w', Similar = new List<char>() {  } },
            new Character() { Value = 'x', Similar = new List<char>() {  } },
            new Character() { Value = 'y', Similar = new List<char>() {  } },
            new Character() { Value = 'z', Similar = new List<char>() { 's' } },
            new Character() { Value = '0', Similar = new List<char>() { 'o' } },
            new Character() { Value = '1', Similar = new List<char>() { 'i', 'l' } },
            new Character() { Value = '2', Similar = new List<char>() {  } },
            new Character() { Value = '3', Similar = new List<char>() { 'e' } },
            new Character() { Value = '4', Similar = new List<char>() { 'a' } },
            new Character() { Value = '5', Similar = new List<char>() { 's' } },
            new Character() { Value = '6', Similar = new List<char>() {  } },
            new Character() { Value = '7', Similar = new List<char>() {  } },
            new Character() { Value = '8', Similar = new List<char>() {  } },
            new Character() { Value = '9', Similar = new List<char>() {  } },
        };

        private List<string> calculated = new List<string>();

        private void Process(string s, string original)
        {
            char[] ca = s.ToCharArray();

            foreach (char c in ca)
            {
                Character cs = characters.Where(x => x.Value == c).FirstOrDefault();

                foreach (char ch in cs.Similar)
                {
                    string f = s.Replace(c, ch);

                    if (!calculated.Contains(f) && f != original)
                    {
                        calculated.Add(f);

                        Process(f, original);
                    }

                }
            }
        }

        internal List<string> GetList(string text)
        {
            Process(text.ToLower(), text.ToLower());

            return this.calculated;
        }
    }

    internal class Character
    {
        internal Character()
        {
            this.Similar = new List<char>();
        }

        internal char Value { get; set; }
        internal List<char> Similar { get; set; }
    }
}

Executing this program with the string “emiliano” you get this list of output strings

3miliano
3niliano
eniliano
emiliamo
3miliamo
3m1l1amo
em1l1amo
en1l1ano
3n1l1ano
3nlllano
enlllano
emlllamo
3mlllamo
3m111amo
em111amo
en111ano
3n111ano
3niiiano
eniiiano
emiiiamo
3miiiamo
3miii4mo
emiii4mo
eniii4no
3niii4no
3n1114no
en1114no
em1114mo
3m1114mo
3mlll4mo
emlll4mo
enlll4no
3nlll4no
3nlll4n0
enlll4n0
emlll4m0
3mlll4m0
3m1114m0
em1114m0
en1114n0
3n1114n0
3niii4n0
eniii4n0
emiii4m0
3miii4m0
3miiiam0
emiiiam0
eniiian0
3niiian0
3n111an0
en111an0
em111am0
3m111am0
3mlllam0
emlllam0
enlllan0
3nlllan0
3n1i1ano
en1i1ano
em1i1amo
3m1i1amo
3mlilamo
emlilamo
enlilano
3nlilano
3nl1lano
enl1lano
eml1lamo
3ml1lamo
3mi1iamo
emi1iamo
eni1iano
3ni1iano
3ni1i4no
eni1i4no
emi1i4mo
3mi1i4mo
3ml1l4mo
eml1l4mo
enl1l4no
3nl1l4no
3nlil4no
enlil4no
emlil4mo
3mlil4mo
3m1i14mo
em1i14mo
en1i14no
3n1i14no
3n1l14no
en1l14no
em1l14mo
3m1l14mo
3mili4mo
emili4mo
enili4no
3nili4no
3nili4n0
enili4n0
emili4m0
3mili4m0
3m1l14m0
em1l14m0
en1l14n0
3n1l14n0
3n1i14n0
en1i14n0
em1i14m0
3m1i14m0
3mlil4m0
emlil4m0
enlil4n0
3nlil4n0
3nl1l4n0
enl1l4n0
eml1l4m0
3ml1l4m0
3mi1i4m0
emi1i4m0
eni1i4n0
3ni1i4n0
3ni1ian0
eni1ian0
emi1iam0
3mi1iam0
3ml1lam0
eml1lam0
enl1lan0
3nl1lan0
3nlilan0
enlilan0
emlilam0
3mlilam0
3m1i1am0
em1i1am0
en1i1an0
3n1i1an0
3n1l1an0
en1l1an0
em1l1am0
3m1l1am0
3miliam0
emiliam0
enilian0
3nilian0
3m1l1ano
em1l1ano
emlllano
3mlllano
3m111ano
em111ano
emiiiano
3miiiano
3miii4no
emiii4no
em1114no
3m1114no
3mlll4no
emlll4no
emlll4n0
3mlll4n0
3m1114n0
em1114n0
emiii4n0
3miii4n0
3miiian0
emiiian0
em111an0
3m111an0
3mlllan0
emlllan0
em1i1ano
3m1i1ano
3mlilano
emlilano
eml1lano
3ml1lano
3mi1iano
emi1iano
emi1i4no
3mi1i4no
3ml1l4no
eml1l4no
emlil4no
3mlil4no
3m1i14no
em1i14no
em1l14no
3m1l14no
3mili4no
emili4no
emili4n0
3mili4n0
3m1l14n0
em1l14n0
em1i14n0
3m1i14n0
3mlil4n0
emlil4n0
eml1l4n0
3ml1l4n0
3mi1i4n0
emi1i4n0
emi1ian0
3mi1ian0
3ml1lan0
eml1lan0
emlilan0
3mlilan0
3m1i1an0
em1i1an0
em1l1an0
3m1l1an0
3milian0
emilian0

To modify the behavior of the program you can easily modify the “characters” list

The Smith Project

The project

The project starts from the desire to monitor the Internet in search of threats but also in search of situations that are not correlated with each other but which, with time or with support, may be at the basis of larger and currently unpredictable phenomena.

The first phase of the project deals with timely monitoring: the solution monitors the domains that are registered, collects information on registrations and hosting and checks the contents of the sites. This step allows you to quickly identify the different types of cyber threats. The collected data can be used for investigations and analyzes.

When a threat (present or probable) is identified, this is reported to security companies who send it to the specific blacklist and then a tweet is produced which is published on my profile: https://twitter.com/ecarlesi

The analysis of the data collected during this phase can be used as a history to identify patterns that allow forecasts on future scenarios.

The second phase of the project aims to produce evidence of phenomena deriving them from patterns discovered by the analysis performed by the components operating in phase one.

Currently, approximately 250000-300000 second-level domains are registered every day. Many of these domains are used to carry out cyber threats: spam, phishing, c2c, etc.

The information that can be acquired through the WHOIS service is not really useful in most cases. In fact, due to the anonymization options, the data are too generic and do not allow to be traced back to the real owner of the domain.

The only fact that is currently taken into account by the solution is the company that registered.

Not all providers have the same reputation. Users who make massive registrations, for example, tend to use cheaper providers who therefore see their reputation lower than others and consequently we attribute a lower initial score to registrations made with these companies.

Another indicator that is taken into consideration by the solution is that linked to the SSL certificate, its issuer and its duration.

This first information collected contributes to the production of a score that is associated with each domain. This score is added to that produced by the subsequent phases and thus contributes to the overall evaluation of the domain.

The main analysis phase is the one where the contents of the website are analyzed. The contents are downloaded and analyzed to verify that there is clearly dangerous or potentially dangerous content. The verification of the contents is based on a database of signatures which is enriched daily and which in the future will be able to learn from the analysis history.

The solution is based on several underlying systems which interacting allow to implement the required logic. The following paragraphs describe the main systems and their roles.

Zefiro

The Zefiro project was born from the idea of having active monitoring of the domains that are registered. This monitoring allows you to “see what happens in the world” before this actually happens (the purchase of the Internet domain, in fact, turns out to be one of the first activities that are carried out when starting a project). The project fulfills this requirement: to receive notification of domains that are registered in a short time, on average a few (10-16) hours.

This component was developed using .NET Framework 4.7 and runs on Windows 2019 using a SQL Server 2019 database. The evolution of this project will be in its rewrite using .NET Core.

Currently the component writes its logs into files. In the future, these files will have to flow into a logs management platform to allow more immediate monitoring and the creation of alerts in the face of logged events.

Miniluv

This project uses information related to the domain (domain name, WHOIS, HTTPS certificate and more) to associate a risk score to each domain name. This score is used later to alter the normal monitoring mode. The domains with a score below a certain threshold are sent via a notification to the subscribers of a specific mailing list.

This component was developed using .NET Framework 4.7 and runs on Windows 2019 using a SQL Server 2019 database. The evolution of this project will be in its rewrite using .NET Core.

Currently the component writes its logs into files. In the future, these files will have to flow into a logs management platform to allow more immediate monitoring and the creation of alerts in the face of logged events.

Smith

The Smith project implements the logic of monitoring and orchestrates the agents who perform the scans. Each scan produces a report which is saved by Smith and used for statistics and future model training.

The sending of reports to companies in the sector concludes the processing phase in the event that a threat (current or probable) is found. The report is then converted into a tweet and posted to my Twitter account.

The Server component was developed using ASP.NET Core and runs on Linux machines using a SQL Server 2019 database. We currently have three instances in three virtual machines managed by the same physical host. In the future, these services will need to be on physical hardware to improve performance.

The Agent component was developed using .NET Core and runs on Linux machines. Communication with servers takes place via HTTPS calls. We currently have nine instances each on a dedicated virtual machine. The machines are spread across two providers on four continents. The current load on these machines is 90% and to stay below this threshold it was necessary to limit some components, penalizing overall performance.

Currently the component writes its logs into files. In the future, these files will have to flow into a logs management platform to allow more immediate monitoring and the creation of alerts in the face of logged events.

La colpa non è solo dell’utonto

Premetto subito che non ho nulla contro Fastweb, anzi; è il mio provider preferito e questo post cita Fastweb solo come esempio.

Ho notato che Fastweb invia SMS contenenti link al proprio sito. Questa modalità di comunicazione non è a mio avviso corretta, soprattutto perché tende a educare male i propri utenti.

Dato che sappiamo bene come l’utente tenda a non capire chi gli stia scrivendo ed allo stesso tempo ami cliccare in modo compulsivo su qualsiasi link gli compaia, penso che sarebbe il caso di evitare di inviare link che rafforzino questa tendenza insana.

Penso che sarebbe più saggio impegnarsi a non inviare mai link ai propri utenti e ricordare questo agli stessi, magari chiudendo ogni comunicazione con una frase tipo “Ricordati che non ti invieremo mai link, quindi non dovrai mai aprire link che pensi possano arrivarti da noi”. Almeno in caso di incidente si potrò dire al cliente “te l’avevamo detto”.

Ovviamente per poter smettere di inviare link ai propri utenti si renderà necessario avere un sito internet funzionante e soprattutto con un motore di ricerca che faccia il proprio mestiere.

IT Attitude chiude :(

Dopo anni di duro lavoro ed impegno, mio ma non solo, IT Attitude è fallita.

Ho ricevuto l’altro giorno la chiamata da parte dell’avvocato che mi avvisava dell accaduto. C’erano state diverse udienze e diversi rinvii, un po’ dovuti alla pandemia, un po’ al girare di carte dovuto ai meccanismi legali. Io intanto ho provato a trovare una soluzione, cercando di proporre nuove attività a nuovi clienti, ma da solo non sono riuscito ad avviare attività sufficienti a rimettere a posto le cose.

Non è una bella sensazione quella del fallimento. Non è la prima volta che fallisco in qualcosa, però questa volta la cosa è più pesante.

La situazione che però mi sta veramente sullo stomaco è il fatto che tutto questo derivi dal mio errore di aver affidato il futuro della mia azienda ad un cliente di merda. Si è trattato di un errore fatale.

Che lavorare per UniCredit fosse rischioso l’avevo capito rapidamente, eppure nonostante tutto non ho lasciato quando avrei dovuto. Certo, adesso è facile capire quando avrei dovuto lasciare quella palude, però in effetti, con lucidità, anche all’epoca avrei dovuto capire che era un ambiente insano.

Come tutti i fallimenti resta l’esperienza, le competenze acquisite e soprattutto l’amicizia nata con persone fantastiche.

Non è la fine, restano da sistemare alcune situazioni e poi ci sono nuove avventure, però i coglioni girano.

In tutto questo l’udienza contro UniCredit era stata fissata a giugno… Vedremo che succederà, ormai anche solo per curiosità.

Finalmente udienza!

E finalmente arrivò il 18 giugno! Dopo un paio di rinvii causa COVID, ieri era il giorno dell’udienza per l’ingiunzione di pagamento che abbiamo presentato come IT Attitude verso UniCredit.

L’udienza si è tenuta presso il Tribunale di Milano e nonostante il mio avvocato avesse provveduto ad avvisarmi che si sarebbe svolta “nelle forme della trattazione scritta” io qualche giorno prima mi ero già attrezzato per la trasferta! Per fortuna che la formula, per quanto io ignorante in materia, mi aveva messo la pulce nell’orecchio e così avevo deciso di chiamare il mio avvocato per chiedere conferma. Mi disse che non c’era da andare da nessuna parte e che avremmo depositato note scritte. Bene, mi sono risparmiato una gita inutile a Milano e relativa figuraccia…

Oltre alle nostre note anche l’avvocato di UniCredit ha depositato le sue. Dopo aver letto la nota un paio di volte ho pensato di riprendere quanto scrittovi per questo post, un po’ per raccogliere le idee, un po’ per condividere con voi quello che succede in alcune presunte “grandi aziende”.

Nei nostri atti abbiamo riportato il fatto che il nostro credito nei confronti di UniCredit è maturato a fronte di comportamenti interni a UniCredit stessa in contrasto delle loro stesse regole aziendali. Questo ovviamente l’avvocato di UniCredit non può accettarlo come dato di fatto, però (non avendo io ragione di pensare che esso sia uno sprovveduto) sono certo che in cuor suo ben sappia come funzionino le cose. La realtà, anche se inelegante, resta tale, quindi ritengo sano riportare un po’ di numeri e fatti.

Nelle note di UniCredit si legge “presunta e non provata “consuetudine consolidata tra le parti””. Ovviamente UniCredit contesta il fatto che gli si dica che alcuni dei suoi facciano come cazzo gli pare, ma tant’è.

La visione paradisiaca in cui a inizio anno si assegna un budget e con quello i manager fanno i progetti, non funziona sempre. Anzi, spesso già ad Aprile li trovi che cercano soldi per fare cose (utili o meno, dipende dai punti di vista) e molto spesso per cercare di tappare casini fatti a suo tempo ed ancora pendenti. Nel nostro caso, il casino era che a fronte di un budget per un’attività da svolgere con alcune persone, ci fu chiesto di fare diverse altre attività, con più persone coinvolte. Oltre a questo ci fu chiesto di subappaltare attività a società terze, non accreditate presso UniCredit (chissà come furono scelte quelle società) e di comprare materiale da far poi passare come giornate.

Qui il primo dubbio che mi viene rileggendo (immagino che sarebbe dovuto venire anche a qualcuno in UniCredit) è, ma questi con un team di x persone, come fanno a fattura più di x * <giorni del mese>? E si perché se metti nero su bianco che una persona ha lavorato 40 giorni in un mese, in un’azienda normale qualcuno ti chiama e ti chiede chiarimenti, in UniCredit no. O meglio, in alcuni casi lo fanno e in altri no (chissà come discriminano).

Così ad esempio, a fronte di un ordine per un attività di “running”, abbiamo emesso fattura per l’intero importo annuale, ad Aprile. Nessuno ha chiesto come mai fatturassimo l’attività otto mesi prima. Ma un caso potrebbe non essere consuetudine, vediamo se ne trovo altri…

Ad esempio, visto che a fronte delle continue richieste di UniCredit noi eravamo sempre sotto di ordini, la risposta della banca quale era? Un classico “fattura su questo”, dove “questo” identificava un PO emesso per un’attività di cui non avevamo mai sentito parlare, con richiedenti a noi sconosciuti, ma evidentemente compiacenti. Ad esempio:

  • 2000408157
  • 2000416132
  • 2000402596
  • 2000398771
  • 2000393392
  • 2000391292
  • 2000381248
  • 2000351132
  • 2000331446
  • 2000297022

Ne riporto giusto una decina ma l’elenco di ordini “al portatore” che sono stati utilizzati da UniCredit per gestire il credito nei nostri confronti è ben più ampio. Anche questo è indice di “presunta e non provata “consuetudine consolidata tra le parti””? Se questo è normale non oso immaginare cosa altro possa succedere li dentro.

Un altro passaggio che trovo quasi divertente è questo:

“La It Attitude S.r.l., inoltre, risulta sottoposta a procedura concorsuale (cfr doc. 29 parte attrice) e sussiste, pertanto, il concreto rischio che Unicredit Services S.c.p.a. non riesca a conseguire la restituzione degli importi versati in caso di concessione della provvisoria esecutività al decreto ingiuntivo opposto.”

In parte ha ragione, la mia azienda versa in pessime acque. Quello che però bisogna anche dire è che questa situazione deriva dal fatto di avere cominciato a lavorare con UniCredit. Mi sono trovato invischiato in una situazione che pur sembrandomi strana mi è stata fatta passare per normale. Io ho sbagliato e ho dato fiducia a UniCredit e a chi la rappresentava e ho cominciato a seguire le loro regole. Ho sbagliato perché non avevo valutato che le loro regole servono solo a tutelare loro.

Per adesso direi basta qui, magari farò una rubrica settimanale con un post ogni lunedì. La chiamerò “pillole di UniCredit”.

YI Action Cam case

After trying a couple of cases for my YI Action Cam I decided to try to print one for use with the GoPro chest mount.

With the classic one that you buy on Amazon, while recording mountain bike videos, I experienced two problems: a loud background rustle and a limit in the useful inclination.

Using the classic case, the sound problem I think is due to a rustling that occurs inside the case. Use this printed case leaves the microphone exposed instead.

Download: https://v1.tinkercad.com/things/hG18RYlPKZ6

In addition to the printed parts, the following screws and nuts are required for assembly:

  • 4x screw M3x30mm
  • 4x screw M3x15mm
  • 8x self-locking nut M3

The base compatible with GoPro support is not integrated in the case, this is to allow everyone to develop new supports for different uses.

Argilla

Argilla is my new project available on Github.

Argilla is a simple distributed bus for the integration between microservices. The adoption of Argilla allows the elimination of microservice endpoint configuration so that they can be managed more easily.

At present the project is functional even if it is not performing and unstable. Your help could be very useful to improve it 😉

The idea of this project starts from an internal need of my cyber security project developed in .NET Core on Linux. I needed to enable various services to communicate without having to manage a catalog and even worse a distributed configuration. I also had the need to have callbacks from calls that can last for hours.

Creating an Argilla enabled microservice is very simple, just add a reference, a few lines of code and your microservice are ready.

The architecture of Argilla is very simple, there is a Resolver server and its endpoint is configured in the various microservices. Argilla automatically publishes the catalog of services endpoint so that clients can consume the services without previously knowing their locations. If multiple services implement the same service, the client takes turns invoking the services to distribute the load. The client then takes care not to invoke the offline services and turn the requests to those available.