Roberto Piva

API-first development with Quarkus

Sat, 06 Aug 2022 00:00:00 +0000

When designing an API one of the first question you need to answer is who is the user of the API and how does an API solves his problems. Once you defined your use case though, you need to define the API itself. One way to tackle the problem is to start coding the solution and rely on a library or tool to extract the API from the realized service. This approach is conventionally called “code first”, meaning you first code the solution and then extract a formal definition of the API. Typical API definitions are OpenAPI, WSDL, or GraphQL.

API-first

According to Zalando’s REST API design guide and Thoughtworks tech radar, however, the preferred way to design an API is with an “API-first” approach. The API-first approach inverts the order of operations, meaning you first design your API directly in the formal definition, and then you code the service that serves the API (pun not intended).

This approach makes sure that one can develop server, clients, and tests all at once, since they all starts with the same specification.

This is what an API is: the API is the product, the documentation and the formal definition is their User Interface, the error codes and mode of interactions are the User Experience.

But how do we do it? Let’s see what tools we have in the Java world.

API-first quarkus server

Suppose we have already defined an API in the form of OpenAPI. For simplicity and ease of comparison, we use the classic example: the pet store. We gather the OpenAPI specification from their OpenAPI sample catalog (direct link to OpenAPI spec), and then we need to generate the base code for our server. We have multiple options here:

if we are designing a server for a fixed API we may want to generate the project skeleton once and probably edit the generated files directly
if on the other hand we are currenty developing the API itself or we want to promptly fail the build when we change the API, we should generate only standard beans and service interfaces.

What we will do for this example is the latter approach, and we will use two handy tools:

OpenAPI official Java code generator tool and maven plugin
quarkus framework for developing fast cloud-native applications

Let’s start!

First, we assume we have the quarkus cli installed (use the great SDKMAN! if you want an easy install) and we start with a

$ quarkus create app pro.robertopiva:api-first-pet-store \
 --extension=resteasy-reactive-jackson,hibernate-validator
$ cd api-first-pet-store

You can then remove the sample code and tests since we will replace them with generated code. Then we want to download the OpenAPI spec for ease of use.

$ curl https://raw.githubusercontent.com/OAI/OpenAPI-Specification/main/examples/v3.0/petstore-expanded.json -o petstore.openapi.json
## for a fancier version:
$ curl https://raw.githubusercontent.com/OAI/OpenAPI-Specification/main/examples/v3.0/petstore-expanded.json | jq > petstore.openapi.json

And now we need a way to generate the rest interfaces and the java beans, so we configure the OpenAPI maven generator plugin. The plugin itself is very general, and can be used in a variety of contexts. Generator classes are all listed in https://github.com/OpenAPITools/openapi-generator/tree/master/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages and configuration variables are also listed in https://openapi-generator.tech/docs/generators/java.

For our case we will use:

jaxrs-spec generator (JavaJAXRSSpecServerCodegen) to generate only the java REST interfaces
of course generate models (java beans)
java 8-compatible dates
skip generation of swagger annotations (we start from openapi spec after all)
also skip supporting files (maven project), generated tests, generated documentation
skip authentication-related files

The corresponding maven plugin XML is written below:

<plugin>
 <groupId>org.openapitools</groupId>
 <artifactId>openapi-generator-maven-plugin</artifactId>
 <version>6.0.1</version>
 <executions>
 <execution>
 <goals>
 <goal>generate</goal>
 </goals>
 <configuration>
 <inputSpec>${project.basedir}/petstore.openapi.json</inputSpec>
 <generatorName>jaxrs-spec</generatorName>
 <configOptions>
 <dateLibrary>java8</dateLibrary>
 <useSwaggerAnnotations>false</useSwaggerAnnotations>
 <!--ensure we only generate java interfaces and no implementation skeleton-->
 <interfaceOnly>true</interfaceOnly>
 </configOptions>
 <apiPackage>pro.robertopiva.api</apiPackage>
 <modelPackage>pro.robertopiva.beans</modelPackage>
 <generateModelTests>false</generateModelTests>
 <generateModelDocumentation>false</generateModelDocumentation>
 <generateSupportingFiles>false</generateSupportingFiles>
 <generateApiTests>false</generateApiTests>
 <generateApiDocumentation>false</generateApiDocumentation>
 <auth>false</auth>
 </configuration>
 </execution>
 </executions>
</plugin>
<!--maven helper plugin to add generated sources to maven project-->
<plugin>
 <groupId>org.codehaus.mojo</groupId>
 <artifactId>build-helper-maven-plugin</artifactId>
 <executions>
 <execution>
 <phase>generate-sources</phase>
 <goals>
 <goal>add-source</goal>
 </goals>
 <configuration>
 <sources>
 <source>${project.build.directory}/generated-sources/openapi/src/gen/java</source>
 </sources>
 </configuration>
 </execution>
 </executions>
</plugin>

After running the canonical ./mvnw clean package we should have:

$ exa --tree target
target
├── [...]
├── generated-sources
│ ├── annotations
│ └── openapi
│ └── src
│ └── gen
│ └── java
│ └── pro
│ └── robertopiva
│ ├── api
│ │ └── PetsApi.java
│ └── beans
│ ├── Error.java
│ ├── NewPet.java
│ ├── Pet.java
│ └── PetAllOf.java
[...]

We can clearly see that the plugin generated beans and interfaces.

What now? We implement those interfaces!

On our src/main/java folder we can now implement PetsApi interface in our new class.

See here a snippet without implementation:

public class Pets implements PetsApi {

 @Override
 public Pet addPet(@Valid @NotNull NewPet newPet) {
 return null;
 }

 @Override
 public void deletePet(Long id) {
 }

 @Override
 public Pet findPetById(Long id) {
 return null;
 }

 @Override
 public List<Pet> findPets(List<String> tags, Integer limit) {
 return null;
 }
}

Please note that this class is not part of the generated code, we specifically skipped the generation of “basic implementation”. As we can see, with the interface being already set in generation, we can focus on the implementation rather than on the definitions.

You can see a quick in-memory implementation of PetsApi at https://github.com/civitz/quarkus-api-first/blob/main/src/main/java/pro/robertopiva/api/Pets.java

Changing the API

Another benefit of the API-first approach is that to change the API we need to first change it’s documentation, i.e. the OpenAPI spec.

To do this, we try to add another optional parameter to the findPets API and see what happens. If we add the following json snippet:

// last parameter
{
 "name": "limit",
 "in": "query",
 "description": "maximum number of results to return",
 "required": false,
 "schema": {
 "type": "integer",
 "format": "int32"
 }
},
// added optional parameter
{
 "name": "page",
 "in": "query",
 "description": "page number (max 'limit' items per page')",
 "required": false,
 "schema": {
 "type": "integer",
 "format": "int32"
 }
}

Once we compile with ./mvnw clean package we obtain:

[INFO] --- maven-compiler-plugin:3.8.1:compile (default-compile) @ api-first-pet-store ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 6 source files to /workspace/api-first-pet-store/target/classes
[INFO] -------------------------------------------------------------
[ERROR] COMPILATION ERROR :
[INFO] -------------------------------------------------------------
[ERROR] /workspace/api-first-pet-store/src/main/java/pro/robertopiva/api/Pets.java:[18,8] pro.robertopiva.api.Pets is not abstract and does not override abstract method findPets(java.util.List<java.lang.String>,java.lang.Integer,java.lang.Integer) in pro.robertopiva.api.PetsApi
[ERROR] /workspace/api-first-pet-store/src/main/java/pro/robertopiva/api/Pets.java:[49,5] method does not override or implement a method from a supertype
[INFO] 2 errors
[INFO] -------------------------------------------------------------
[INFO] ------------------------------------------------------------------------
[INFO] BUILD FAILURE
[INFO] ------------------------------------------------------------------------

This is beneficial for any situation where you want to be sure that the code respect the contract, i.e. the API.

Bonus: native compilation

We are using quarkus and we are not adding any incompatible dependency, so we can also compile to native code using the specific maven profile: ./mvnw clean package -Pnative.

Once compiled, our API-first project boots in microseconds:

$ ./target/api-first-pet-store-1.0.0-SNAPSHOT-runner
__ ____ __ _____ ___ __ ____ ______
--/ __ \/ / / / _ | / _ \/ //_/ / / / __/
-/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/
2022-08-06 19:29:06,858 INFO [io.quarkus] (main) api-first-pet-store 1.0.0-SNAPSHOT native (powered by Quarkus 2.11.1.Final) started in 0.025s. Listening on: http://0.0.0.0:8080
2022-08-06 19:29:06,861 INFO [io.quarkus] (main) Profile prod activated.
2022-08-06 19:29:06,861 INFO [io.quarkus] (main) Installed features: [cdi, hibernate-validator, resteasy-reactive, resteasy-reactive-jackson, smallrye-context-propagation, vertx]

Concusions

Some companies are organized so that API clients are automatically, and fully, generated from OpenAPI spec. This facilitate integration both within and outside the company: documenting the API is part of the development process.

The Quarkus framework and OpenAPI generator enable an API-first approach while simultaneously maintaining high performances and native compilation as a bonus.

JWT for service-to-service auth

Sat, 23 Jul 2022 00:00:00 +0000

Microservice architecture has been around for years now, and I think it’s here to stay. The approach has many advantages, but it brings some challenges along the way. One of which is authentication/authorization.

Authentication and authorization are two very distinct concerns that are often treated together, expecially if the information used to verify them is the same (for example a username or a session identifier). From now on we will refer to both terms together as “auth”.

An example: microservice architecture

In this little essay we consider a web-facing application with a microservice architecture, we assume we have a cluster where internal connectivity is not exposed, and we also have one or more services that are exposed on the internet as part of their responsibility.

In this context one would think that after the outermost services handle auth, then the auth problem “disappears” within microservices’ network. This would result in inner services having no auth, meaning integration would be very easy. It would also let everyone within the network to access data and invoke procedures without any check. This scenario assumes good intentions, so a misconfigured process or a bad actor could access or change data from within the network.

One way to partially deal with the unlimited access is acting at the network level by either firewall rules, network policies in kubernetes, or by solutions like a service mesh. Another approach would be to authenticate each and every request even within the cluster. And here is where JWT shines!

JSON Web Token

JWT - or JSON Web Token - is a standardized tool to carry data over the network, expecially over HTTP. It consists in a JSON object with conventions on fields and also customizable fields, which is then encoded with Base64URL. The encoding happens to be compatible with HTTP headers, which is convenient because it will be the way we use it. JWT is also optionally signed (JWS - JWT signature) and/or encrypted (JWE - JWT encryption).

More in depth, a JWT is composed of two or more JSON objects:

a header object which describes the token type and optional sign and encryption algorithms
a payload object containing data
an optional signature object
one or more encryption objects depending on the chosen algorithm

The header object has standard fields:

type (typ) represents the type of token, it can be a mime type for or “JOSE”
algorythm (alg) optionally represents the signature or encryption algorithm. Note that when type is encrypted/signed the algorithm can still be “none” and this renders the token unencrypted/unverifiable

The payload object has standard fields called “claims” for common concepts:

unique identifiers
validity timestamps and validity limits
audience specification for the token
token issuer specification
the subject of the token, i.e. who is the verified user/person/service authorized with this token

The payload can be freely extended with custom claims, as long as they are represented with standard JSON. A possible use of this is mapping capabilities of the authenticated entity, or carrying user information if JWT is used to represent a session.

Enhancing the example

So what does this bring to the context of microservices? Consider extending the original scenario: the outermost service verifies the auth of the caller, and also creates a JWT that represents the caller. It additionally sign the token, obtaining a JWS. Now you get a verifiable token that can be used to auth the request within all the internal calls inside the microservice architecture. In this scenario we only consider JWS (or JWE) because JWT by itself is easy to change, we need at least a signature to trust the caller.

Other services should accept the call only if they:

verify the signature of the token
check whether they trust the issuer (“iss” claim in the payload)
check whether they are part of the audience for the token. That is, if their name is in the “aud” list in the payload.
check if token is still valid according to timestamp limits (“exp”, “nbf” claims, see RFC)

This is nothing new but the biggest advantages of JWT/JWS is that these verifications can happen without calling other services. In other words, properly crafted JWTs provide stateless authentication/authorization.

Final remarks and conclusion

There are added benefits of JWT:

you can pass JWT along the next service in chained calls
you can carry contextual information like transaction id, or user data
for HTTP services you only add a header, so you get to keep a clean API
testing can be enabled by ignoring JWT signature or by configuring a trusted issuer, no fancy setup is needed
format is standard and uses formats and encodings that are easy to decode and debug
it is becoming pretty common so it’s easy to find API gateways and framework libraries that support it

Limitations:

you need to configure your gateway (or web-facing server) to create the JWS
you need an infrastructure to handle certificates, although with solutions like letsencrypt this is becoming easier to do
you need to whitelist accepted algorithms and issuers of JWT on each service
any process that initiates calls to JWT-protected services from within the cluster has to either pass through an API gateway or have a mean to create a trusted JWT by itself
since claims can be personalized and JWT does not have a fixed schema, you need to agree on the actual combination of claims you want to use

I would also add that JWT are not limited to a microservice environment. The standard is agnostic and has been successfully used:

as a soft replacement for HTTP session in frontend-backend communication
as a format for information exchange between trusting parties
as part of OpenID Connect, a standardized mechanism to authenticate a user on a service via a third party identity provider

I think JWT is a nice versatile tool to encode information. I really liked what this tiny JSON enables in a microservice environment, enhancing the security of a system without disrupting the protocols or affecting the developer experience.

Test code performance with JMH

Sun, 14 Nov 2021 00:00:00 +0000

I was reviewing a piece of code for a template renderer lately, and noticed something was a little bit off. A template renderer is used to make personalized documents given a fixed text (the template) and a set of parameters.

For example: if we want to send postcards to 1000 friends, and the text is the same a part from the name we can make a template with a placeholder text in it in place of the name. The template’s placeholders usually follow a convention, for example if we want to make personalized documents with Hello name inside, where name is changed for every person we want to send this document, then the template will be something like Hello [name], ...

A template renderer is an algorithm which takes a template (a string with token or placeholders) and some parameters (a map of string to string) and returns a rendered text (also a string). In the rendered text the algorithm:

replaces every matched placeholder with the parameters value (e.g. every occurrence of [name] with John)
leaves placeholders if there is no replacement (e.g. if there is no replacement for [destination] for the template We will reach [destination], then the result of the render is We will reach [destination])
ignores any extra parameters that are not mentioned as placeholders
ignores corner cases, like unmatched characters (hello, [i [like [brackets ) or nested/unmatched template (this [is a nested [bracketName]])

To put it all together, if we have a template:

Hello [name],
Meet me at [place] at around [time].

With parameters:

{
 "name": "Jane",
 "place": "the park",
 "time": "noon"
}

Then the result should be:

Hello Jane,
Meet me at the park at around noon.

So I was reviewing a template renderer, and the code did not look very performant. How would I evaluate the different performance of a new algorithm? We need a benchmark! The de facto standard of benchmarks in the Java world is JMH - Java Microbenchmark Harness. JMH is a tool to build code benchmarks that accounts for some peculiarities of the JVM (Java Virtual Machine), such as compiler optimizations, bytecode optimizations, and JIT (Just In Time) optimizations.

Suppose we have a sample naive algorithm that accepts square brackets ([ and ]) as placeholder indicator in template - please note that in our sample we use the VAVR library:

public static String naiveRegexReplace(String template, Map<String, String> values) {
 return values.foldLeft(template, (replaced, kv) -> replaced.replaceAll("\\[[\\s]*" + kv._1 + "[\\s]*\\]", kv._2));
}

To test its performance we need to set up a JMH project. You can do it via the convenient maven archetype:

mvn archetype:generate \
-DinteractiveMode=false \
-DarchetypeGroupId=org.openjdk.jmh \
-DarchetypeArtifactId=jmh-java-benchmark-archetype \
-DgroupId=com.mycompany \
-DartifactId=benchmarks \
-Dversion=1.0-SNAPSHOT

Then you can go straight to edit the MyBenchmark class.

For our case we need a sample data, which we can generate using the @State(Scope.Benchmark) annotation on a class with a no-arg constructor. This avoids a compiler optimization which would make the compiler return the result of a computation, as long as it can calculate that the result at compile-time.

@State(Scope.Benchmark)
public static class AllMatched10AverageText {
 public String template;
 public Map<String, String> values;

 public AllMatched10AverageText() {
 values = Stream.range(0, 10)
 .toMap(i -> Tuple.of("key" + i, "value" + i));
 String mediumGap = Stream.range(0, 100)
 .map(ign -> "rand")
 .mkString("");
 template = values.map(Tuple2::_1).mkString("[","]"+mediumGap+"[","]");
 }
}

The code above generates a template with 10 placeholders, evenly spaced with text, for a total of around 3.5KB of text. Then it also generate 10 values for the placeholder text, so that all placeholders have a matched value. This represents an average case for, say, an email.

Now for the actual benchmark:

@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void _10_args_averageCase_naiveRegex(AllMatched10AverageText torender, Blackhole blackhole) {
 blackhole.consume(TemplateRenderers.naiveRegexReplace(torender.template, torender.values));
}

Notice the Blackhole usage: if the compiler detects that we make no use of a certain result, and it can determine that it can delete code, then our benchmark would measure nothing. To avoid this we can use the Blackhole, which consumes the result, so that the compiler will not optimize our code away.

We can run the benchmark by running the default main method. The results are shown in the coonsole like the following (text has been modified to fit this post):

Benchmark Mode Cnt Score Error Units
MyBenchmark._10_args_averageCase_naiveRegex avgt 6 224,164 ± 8,813 us/op

Well, now we have a baseline! We can now work on a different algorithm. For the specific case we noticed that the string is being duplicated over and over for each round of replaceAll. We implemented a windowed/scrolling template renderer, you can see the code below:

public static String scrolling(String template, Map<String, String> values) {
 int pendingBracketPos = -1;
 StringBuilder buffer = new StringBuilder(template.length());
 for (int pos = 0; pos < template.length(); pos++) {
 char c = template.charAt(pos);
 if (c == '[') {
 if (pendingBracketPos != -1) {
 buffer.append(template, pendingBracketPos, pos);
 }
 pendingBracketPos = pos;
 } else if (c == ']') {
 if (pendingBracketPos == -1) {
 buffer.append(c);
 } else {
 String possibleKey = template.substring(pendingBracketPos + 1, pos).trim();
 Option<String> possibleValue = values.get(possibleKey);
 if (possibleValue.isDefined()) {
 buffer.append(possibleValue.get());
 } else {
 buffer.append(template, pendingBracketPos, pos + 1);
 }
 pendingBracketPos = -1;
 }
 } else if (pendingBracketPos == -1) {
 buffer.append(c);
 }
 }
 return buffer.toString();
}

We now have two different algorithms we can compare between, so let’s do it! Add another benchmark:

@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void _10_args_averageCase_scrolling(AllMatched10AverageText torender, Blackhole blackhole) {
 blackhole.consume(TemplateRenderers.scrolling(torender.template, torender.values));
}

Now we can compare the two results by running another time the benchmark:

Benchmark Mode Cnt Score Error Units
MyBenchmark._10_args_averageCase_naiveRegex avgt 6 224,164 ± 8,813 us/op
MyBenchmark._10_args_averageCase_scrolling avgt 6 40,114 ± 1,729 us/op

Well, that’s a speedup of ~5x!

Now you’ve seen the basis of JMH performance testing, you can further test your algorithms’ performance by:

adding different combination of data
confronting more algorithms together
changing the benchmark parameters such as:
- warmup runs to trigger JIT optimizations
- forks to run the test on multiple instance of the same JVM to account for slight context variations between runs (e.g. cpu power state, background activity, memory paging situation,etc…)
- measurement iterations
- garbage collection
- profiling

We added a full example in the java experiments repo, you can see the code (with tests!) here. The repo also contains:

an even more optimized version of the scrolling algorithm
the possibility to generate a runnable jar to run the benchmark as a standalone app
more benchmark cases
unit tests for all the algorithms

Have a nice performance testing!

Pulizia e ottimizzazione di un computer Windows

Wed, 04 Aug 2021 00:00:00 +0000

Nota: questo post è una libera traduzione di un post di decent security. Trovate il suo lavoro presso https://decentsecurity.com

** Questa pagina è in costruzione **

[Pagina aggiornata l’ultima volta il 2022-01-18]

“Faccio del mio meglio per rendere tutto questo il più facile possibile, ma ci sono diverse tecniche avanzate in questa guida rispetto al resto del sito”

Questa è una guida alla risoluzione di problemi e manutenzione per Windows 7 e successivi. Vi aiuterà inoltre a rimuovere molti virus e riparare i danni causati da essi. Queste procedure possono essere d’aiuto per macchine anche piuttosto vecchie. Se il vostro computer è una macchina di lavoro, chiedete consiglio al vostro referente tecnico IT prima di procedere.

Tutti questi task sono stati eseguiti da me o da miei script su decine, centinaia o a volte migliaia di computer. Potete leggere le mie qualifiche qui.

L’ordine delle sezioni è voluto. Per esempio - eliminare alcuni programmi, eliminare i file temporanei, e poi riavviare può lasciare i programmi in uno stato inconsistente.

Non usare strumenti per pulire il registro o ottimizzatori di sistema. Leggi perchè.

Prestare attenzione utilizzando strumenti per rimuovere le telemetrie o migliorare la privacy di Windows 10. Essi possono modificare parametri di sistema che non dovrebbero, e inavvertitamente disattivare funzioni di sicurezza, rendendovi vulnerabili e danneggiando funzionalità di Windows. So che è invitante “mettere il turbo al tuo PC” con strategie tipiche dei tempi di Windows XP, ma ricordate che questi strumenti mettono mano a funzionalità di basso livello che non comprendete.

Se state aggiornando a Windows 7 un computer che è stato spento per oltre un anno, o state installando da zero, ci sono dei problemi noti. Seguite questa guida per risparmiarvi ore di lavoro: Windows 7 Fast Update.

1.) Controllo del disco fisso e eventuali errori prima di partire

I dischi fissi possono essere una causa silente di diversi errori inspiegabili, rallentamenti, e crash. Il mio strumento preferito è WinDlg di Western Digital. Non serve installarlo e funziona con qualunque disco di qualunque marca. Scaricate il file, eseguite windlg.exe, e fate doppio-click sul disco per fare un controllo veloce. Ci vogliono dai 2 ai 10 minuti.
Lo strumento integrato di Monitoraggio Affidabilità o “Visualizza cronologia affidabilità” vi mostrerà lo storico degli errori e dei problemi sulla vostra macchina.
[Per esperti] Controllate se ci sono state schermate blu (bugcheck) con BlueScreenView.

2.) Rimozione programmi spazzatura

Questa sezione è i più tecnici. Se non siete sicuri su cosa fare, riavviate e saltate questa sezione.

Start > scrivi “Programmi e funzionalità”/“App e funzionalità” > Invio

Da questa finestra, disinstalla tutto quello che sembra essere non rilevante o indesiderato. Leggi le videate MOLTO ATTENTAMENTE per essere sicuro di non lasciare tracce dei programmi rimossi accettando qualche clausola. Se non sai cosa sia rilevante o non sei sicuro, non rimuovere alcun programma. Va tutto bene, vedremo più avanti il da farsi.

Se l’antivirus è non aggiornato o scaduto o ha problemi, rimuovilo ora. Un antivirus che non sia aggiornato a ieri è essenzialmente inutile. Se l’uninstaller dell’antivirus è rotto, potete usare questo strumento per la rimozione manuale: ESET AV Remover.

BREAK 1 - Riavvia prima di procedere con i passi successivi

3.) Pulire windows con cleanmgr.exe

Potete liberare giga di spazio (spesso 6GB e oltre) pulendo WinSxS, cosa che nessuno strumento può toccare con tranquillità. Lo strumento integrato in windows è stato migliorato con Windows Update nel 2013. Non fate questo passo in Windows XP.

Start > scrivi “cleanmgr” > premi Ctrl+Shift+Invio per eseguire come amministratore.
Seleziona la linguetta “Pulizia Disco” > seleziona tutto tranne “Downloads” o “Scaricati” > premi OK

Lo strumento di pulizia si chiuderà da solo una volta che ha finito. Non è necessario aspettare che termini, procedete con il prossimo passo.

4.) Pulizia cache Windows Update

Svuotate completamente la cache di Windows Update. Questa procedura è sicura. La cartella verrà rigenerata.

Start > scrivi “servuces.msc” > premi Invio
“Servizio trasferimento intelligente in background” > click destro > Stop
“Windows Update” > click destro > Stop.
Rimuovete la cartella C:\Windows\SoftwareDistribution. Se non è consentito, fermate di nuovo i servizi con i punti 1-3.

Non è necessario riavviare manualmente i servizi di cui sopra.

5.) Rimozione file temporanei con Bleachbit

Normalmente non ci sarebbe ragione di ricorrere a strumenti come Bleachbit. Tuttavia questo ci rende molto facile e veloce il compito di ridurre il numero di file che l’antivirus deve scansionare. Preferisco non indicare ciascuna directory da pulire per farlo a mano.

Scarica ed installa Bleachbit
Lancia Bleachbit
Spunta le seguenti opzioni:
1. Flash > Everything
2. Internet Explorer > Everything
3. System > Logs
4. System > Memory dumps
5. System > Recycle bin
6. System > Temporary files
Lancia la pulizia (clean)

Quando cleanmgr e Bleachbit hanno finito, RIAVVIA.

BREAK 2 - Riavvia prima di procedere con quanto segue

6.) Scansione veloce con antivirus

Lanciate la seguente anche se si ha un antivirus. Questi sono strumenti semplici per una scansione veloce. A questo punto, disattivate temporaneamente il vostro antivirus o rimuovetelo finchè non avete terminato di seguire questa guida.

Microsoft Safety Scanner - Questo è un antivirus senza installazione in un unico EXE (un unico eseguibile, ndt) direttamente da Microsoft. Lanciate una scansione veloce (quick scan). Dovrebbero bastare 10 minuti. Il file pesa circa 160 MB al momento della pubblicazione.
Kaspersky Virus Removal Tool

7.) Controllo e rimozione di malware o software spazzatura

Usate questi strumenti se avete il sospetto che il computer non sia pulito o se ha avuto una infezione in passato.

MalwareBytes AdwCleaner è uno strumento poco conosciuto ma molto efficace per rimuovere quelle piccole cose che insidiano un computer. Controllate con cura le raccomandazioni che vi si presentano prima di accettarle. Necessita di un riavvio dopo l’uso.
MalwareBytes Anti-Malware è il mio strumento di pulizia automatica più gettonato per la pulizia da software malevolo e contro cambiamenti non desiderati del sistema. Se l’utente del computer tende ad installare software di dubbia origine, considerate di acquistare la versione Premium.
Google Chrome Cleanup Tool è un piccolo strumento da Google che usa il motore antivirus ESET per rimuovere software spazzatura. Non è necessario resettare Chrome se non pensate che sia rotto o rovinato.

8.) Controllo di Windows Update e Firewall

Un classico segnale di infezione è se le seguenti impostazioni non possono essere abilitate o non funzionano. Sistematele.

Start > scrivete “Windows Update” > Invio

Controllate gli aggiornamenti. Se non funziona, prendete nota e continuate.
Start > scrivete “Windows Firewall” > Invio

Assicuratevi che sia attivo o che dica di essere gestito da un altro programma. Se desiderate tenerlo spento, almeno assicuratevi che si accenda se lo attivate. Se non funziona, prendete nota e continuate.

Se non funziona Windows Update, riparatelo con Microsoft Windows Update FixIt tool.
Se non funziona Windows Firewall, riparatelo con Microsoft Windows Firewall FixIt tool.

Se nessuno dei precedenti funziona, potete provare Windows services repair tool di Webroot o il Services repair tool di ESET.

9.) DISM RestoreHealth (Windows 8 e successivi)

Questo comando scansionerà il sistema alla rierca di componenti Windows corrotti, e cercherà di ripararli. Ci vorranno 20 minuti.

Start > scrivete “cmd.exe” > premete Ctrl + Shitf + Invio
Apparirà una finestra nera
Scrivete “dism /Online /Cleanup-Image /RestoreHealth”
Se il testo (in inglese) dice che è stato riparato qualcosa, riavviate il computer.

10.) Installate gli aggiornamenti di Windows e configurate l’aggiornamento automatico

Controllate gli aggironamenti e assicuratevi siano impostati per l’aggiornamento automatico.

Se ci sono problemi ad installare gli aggiornamente, provate i passi di seguito. Sfortunatamente ci sono situazione per cui Windwos non può essere ragionevolmente riparato. Tuttavia da Windows 8 in avanti c’è il comando DISM a disposizione per riparare la maggior parte delle corruzioni se ce ne fosse bisogno.

Se gli aggiornamenti falliscono Step 0 - Procedura Microsoft

Microsoft mantiene una procedura guidata di riparazione per aiutarvi a sistemare gli errori di Windows. Siccome sono l’azienda autore di Windows, dovreste prima seguire le loro procedure.

Se gli aggiornamenti falliscono Step 1 - Microsoft FixIt

Lanciate lo strumento di riparazione Windows Update e riavviate.

Se gli aggiornamenti falliscono Step 2 - Controllo dell’integrità dei file di sistema

Start > scrivete “cmd.exe” > premete Ctrl+Shift+INvio per avviare come Administrator
Apparirà una finestra nera
Scrivete “dism /online /cleanup-image /restorehealth” senza i doppi apici e premete Invio (non funziona su Windows 7)
Scrivete “sfc /scannow” senza i doppi apici e premete Invio. Quanto ha finito continuate al passo successivo.
Riavviate e ricontrollate gli aggiornamenti di Windows.

Se gli aggiornamenti falliscono Step 3 - Microsoft FixIt (solo Windows 7)

Se avete Windows 7, segutie le istruzioni per scaricare ed eseguire Microsoft Fixit 50202 (link rotto al 2021-08-27).

Se gli aggiornamenti falliscono Step 4 - Ripristino di catroot2 e componenti di Windows Update

Ripristinate la cartella catroot2 (mi raccomando cancellate il contenuto, non la cartella!)
Scaricate ed estraete il “Reset Windows Update Tool” in una cartella del vostro desktop (link rotto al 2021-08-27, provare con https://docs.microsoft.com/en-us/windows/deployment/update/windows-update-resources per windows 10)
Tasto destro su ResetWUEng.cmd > Esegui come amministratore
Selezionare opzioni 2, 5, 8, 9, 10, 12, riavviate, poi verificare se la presenza di aggiornamenti windows

Se gli aggiornamenti falliscono Step 5 - Controllare se esistono soluzioni a problemi noti

Controllate questa pagina di Microsoft Answers se comprende il vostro codice di errore o sintomi e seguite le istruzioni: How to: Troubleshoot Common Setup and Stop Errors

Se gli aggiornamenti falliscono Step 6 - Strumento Microsoft SUR (solo Windows 7)

Scaricate ed installate Microsoft System Update Readiness Tool. (Windows 7 only) (link rotto al 2021-08-27)
Cercate la sezione 21 a in fondo, “Install Windows 7 hotfix rollup”

Se gli aggiornamenti falliscono Step 7 - Controllo del disco con chkdsk

Controllate se il vostro disco rigido presenta problemi.

Start > scrivete “cmd.exe” > Ctrl-Shift-Invio (esegui come amministratore)
Apparrirà una finestra nera, il prompt dei comandi
Scrivete “chkdsk /r” senza doppi apici.
Premete “y” (o “s” in italiano) e premete Invio
Riavviate il computer
Ritornate al “Se gli aggiornamenit falliscono Step 1” se il controllo disco ripara qualcosa del vostro disco

Se gli aggiornamenti falliscono Step 8 - Rimozione antivirus e reset componenti di rete

Disinstallate il vostro antivirus, riavviate, e seguite le seguenti istruzioni. Tenete a mente che dovrete reinstallare eventuali software tipo VPN dopo questa operazione. Se non sapete cosa sia una VPN, allora non dovete preoccuparvene.

Se gli aggiornamenti falliscono Step 9 - Aggiornamento driver

Seguite la sezione 20 di questa guida.

Se gli aggiornamenti falliscono Step 10 - CheckSUR.log

Questo vale solo per Windows 7, ed è estremamente raro che ce ne sia bisogno. Avviso: questa sezione è altamente tecnica.

Prima di tutto lanciate una scansione per stabilire la salute del disco con WinDlg di Western Digital
Seguite questa guida https://support.microsoft.com/en-us/kb/2700601

Se gli aggiornamenti falliscono Step 11 - Modificate la sezione COMPONENTS

Start > scrivete “cmd.exe” > Ctrl-Shift-Invio (esegui come amministratore)
Apparrirà una finestra nera, il prompt dei comandi
Scrivete i seguenti comandi e premete invio dopo ciascuno:
- REG LOAD HKLM\COMPONENTS C:\Windows\System32\config\COMPONENTS
- REG DELETE HKLM\COMPONENTS /V PendingRequired
Riavviate e controllate gli aggiornamenti di windows.

(Fonte - Karen Hu)

11.) Scansione veloce con SecureAnywhere System Analyzer

SecureAnywhere System Analyzer di Webroot fa una scansione veloce di processi e parti importanti del sistema per oggetti catalogati come malevoli nel “cloud”. Il suo passaggio attiva virus e programmi spazzatura, e non pulisce, quindi normalmente volete lanciarlo dopo che avete fatto un po’ di pulizia. Serve solo a raccogliere informazioni per la vostra diagnosi.

12.) Pulizia di WinSxS con ResetBase (Windows 8+)

Questa procedura di pulizia va più a fondo del comando che abbiamo lanciato all’inizio. Dovevamo essere sicuri che il sistema fosse funzionante prima di fare pulizia di vecchi file di Windows. Clicca qui per spiegazione tecnica su cosa avviene.

Start > type cmd.exe > Ctrl-Shift-Invio (esegui come amministratore)
Scrivete: Dism.exe /online /Cleanup-Image /StartComponentCleanup /ResetBase
Invio

13.) Controllo dell’account utente al massimo

Ascoltatemi. O ascoltate uno dei programmatori Microsoft più esperti. UAC (controllo account utente) è un sistema importante che ha impatti profondi nel sistema, in aree che normalmente non sono visibili. Non è come l’imballaggio con le bolle da togliere prima dell’uso. Esiste per ragioni importante, non è cool toglierlo.

Segui queste istruzioni (o segui queste per istruzioni in italiano, ndt) per impostare UAC al massimo, o “Notifica sempre”. Qualsiasi valore minore permeterebbe ai malware di eseguire istantaneamente operazioni con privilegi di amministrazione. UAC non è magia, è uno livello di protezione che volete usare.

14.) Abilitare SmartScreen (Windows 8+)

Questo strumento verifica assieme a Microsoft e avvisa l’utente nel caso si scarichi ed esegua dei programmi non comunemente usati. Questo controllo previene la maggior parte delle infezioni originate da mail fasulle a meno che l’utente non scelga di procedere nonostante l’avviso di cautela.

Start > Scrivete SmartScreen (o Protezione basata sulla reputazione nelle versioni italiane, ndt) > Clicca “Cambia impostazioni SmartScreen” (in versioni successive si dovrebbe arrivare già sulla schermata con le impostazioni di SmartScreen, ndt)
Sulla sinistra, clicca “Cambia impostazioni Windows SmartScreen”
Seleziona “Chiedi approvazione dell’amministratore” (Windows 8) o “Controlla app e file” (Windows 10)

Nota del traduttore: aggiornamenti recenti di windows hanno cambiato nomenclatura e abilitato nuove funzioni di SmartScreen, se si entra su “Protezione basata sulla reputazione” il consiglio è abilitare tutte le funzioni. Ogni selettore abilita una variante di SmartScreen focalizzata su diverse categorie di file e programmi. Come indicato sopra, questi controlli prevengono infezioni da programmi malevoli.

15.) Pulizia e re-inizializzazione del servizio di ricerca di Windows (Windows Search)

Windows ha un sistema integrato di ricerca e indicizzazione chiamato Windows Search e per utenti con grandi quantità di dati i file di indice possono raggiungere dimensioni di diversi gigabyte. Inoltre Windows Search può occasionalmente corrompersi. Normalmente il servizio si fa manutenzione in autonomia, ma è possibile “resettarlo” al bisogno. La pulizia può liberare anche un gigabyte o più specie se si usa molto Outlook. Questa pulizia va oltre il normale comando di re-indicizzazione di Windows Search, che personalmente trovo poco efficace (a detta dell’autore, ndt).

Questa procedura non è documentata, l’ho imparata dopo ore di ricerca e diagnosi su svariate istanze di Outlook con problemi di ricerca.

Start > Scrivete cmd.exe > Premete Ctrl-Shift-Invio (esegui come amministratore)
Dare i seguenti comandi e premere Invio dopo ciascuno:
1. net stop WSearch
2. RD /S /Q "C:\ProgramData\Microsoft\Search"
3. regedit
In Regedit, trovate e cancellate le seguenti chiavi e cartelle (aiutetevi con la ricerca, ndt):
- Sotto “Current User”: HKEY_CURRENT_USER\Software\Microsoft\Windows Search
- Poi, sotto “Local Machine”: HKEY_LOCAL_MACHINE\Software\Microsoft\Windows Search\SetupCompletedSuccessfully

16.) Pulizia e aggiornamento browser

Verificate manualmente che ogni browser che utilizzate sia alla sua ultima versione

Se l’utente è prono a infettarsi con malware o altri programmi che prendono possesso del computer, o ad avere problemi di performance con i browser, probabilmente è il caso di cancellare la cache e resettare le impostazioni. In altri casi questo potrebbe risultare esagerato. Questi di seguito sono le modalità più semplici per reimpostare i browser, ma almeno sarete sicuri che il sistema sarà pulito. NOTA: Queste procedure cancellano tutte le password e altri dati salvati.

Microsoft Edge

Al momento non ho esperienza sul campo in merito a virus con questo browser, non ho suggerimenti.

Google Chrome

Reimposteremo Chrome da zero.

Esportare i preferiti di Chrome
Disinstallate Google Chrome.
Start > Scrivete %AppData% > Premete Invio. Cancellate la cartella “Google”.
Start > Scrivete %AppDataLocal% > Premete Invio. Cancellate la cartella “Google”.
Cancellate la cartella C:\Program Files (x86)\Google\Chrome
Start > Scrivete regedit.exe > Premete Invio. Cancellate le chiavi HKCU\Software\Policies\Google e HKLM\Software\Policies\Google
Installate Google Chrome con l’installer aziendale 64-bit MSI (scorrete in basso nella pagina). Potete installarlo anche normalmente se volete. Non vi serve aiuto per questo.
Reimportate i preferiti di Chrome.

Mozilla Firefox

Reimposteremo Firefox da zero.

Esportate i preferiti di Firefox.
Disinstallate Mozilla Firefox
Start > Scrivete %AppData%\Mozilla > Premete Invio. Cancellate la cartella “Firefox”.
Start > Scrivete regedit.exe > Premete Invio.Cancellate le chiavi HKCU\Software\Policies\Mozilla e HKLM\Software\Policies\Mozilla
Cancellate la cartella “Mozilla Firefox” sotto C:\Program Files e C:\Program Files (x86)
Installate Firefox dal sito di Mozilla.
Reimportate i preferiti in Firefox.

Internet Explorer

(Questa procedura andrebbe rivista perchè Microsoft ormai installa e raccomanda solo Edge e la sua modalità compatibilità, vi lascio la traduzione per comodità. ndr) Riporteremo Internet Explorer alle sue impostazioni predefinite. Non è un reset al 100% ma ci si avvicina. Assicuratevi di avere Internet Explorer in versione 11. Per sicurezza faremo un backup dei preferiti (è una storia lunga, fidatevi).

Esportate i preferiti di Internet Explorer
Internet Explorer > Premere Alt > Strumenti > Opzioni Internet > Avanzate > Reset
Selezionate “Elimina impostazioni personalizzate” (la traduzione esatta potrebbe essere leggermente diversa, ndt) > Ok

Running gnash on Ubuntu 20.04 with docker

Mon, 16 Nov 2020 00:00:00 +0000

A couple weeks ago I helped my sister upgrade her laptop to the latest ubuntu version available, a process which went without issues. The other day she calls me tell me she needs to play flash files and the player she used no longer works. I chuckled at the thought of flash files in 2020… It turns out academia and book editors still use this technology in their digital media to make it difficult to copy their precious data.

Flash has always been a problem in linux, expecially in the web. Adobe provided a flash plugin for firefox, but for the poor souls who had to play standalone flash files there was no alternative. Then the gnash emerged: an open source flash player which reached a pretty good level of compatibility with the official format. The problem is: gnash is no longer available in official ubuntu repos due to the use of unpatched libraries and the understandable lack of will to update its code.

So how to resolve this impasse? Docker of course, because every other alternative sucks and it turns out it’s easier with docker with the aid of some tricks.

My sister is already familiar with the basics of command line: she can navigate directories, launch commands, upgrade the system, etc… But I cannot force her to learn a lot of docker options. She is not a developer after all.

I stumbled upon this great article by Remy van Elst called Running gnash on Ubuntu 20.04 (in Docker with X11 forwarding), in which he shows how to launch gnash with X11 forwarding.

I needed a more generic way to launch docker: I don’t know in advance which files my sister will need to play. I came up with this variation of the Dockerfile:

FROM ubuntu:18.04

RUN apt-get update && apt-get install -y sudo
RUN apt-get update && apt-get install -y gnash

RUN export uid=1000 gid=1000 && \
 mkdir -p /home/developer && \
 echo "developer:x:${uid}:${gid}:Developer,,,:/home/developer:/bin/bash" >> /etc/passwd && \
 echo "developer:x:${uid}:" >> /etc/group && \
 echo "developer ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers.d/developer && \
 chmod 0440 /etc/sudoers.d/developer && \
 chown ${uid}:${gid} -R /home/developer

USER developer
ENV HOME /home/developer

WORKDIR /home/developer
ENTRYPOINT ["/usr/bin/gnash"]

The same warning about uid and gid apply: we need to build this image on the target machine, and tweak the uid and gid so that they match the current user’s ids. The meaningful change is the ENTRYPOINT command: it lets us launch the docker image as it was a command.

We can launch the image with this command line:

$ docker run -it -e DISPLAY=$DISPLAY --net=host -v /tmp/.X11-unix:/tmp/.X11-unix -v $(pwd):/home/developer gnash filename.swf

I also added a little script in ~/.local/bin/gnash with this content:

#!/bin/bash
docker run -it -e DISPLAY=$DISPLAY --net=host -v /tmp/.X11-unix:/tmp/.X11-unix -v $(pwd):/home/developer gnash $@

This way the command is always available in the command line, with a simple:

$ gnash filename.swf

which is almost the same as having gnash installed.

Happy sister, horray for for docker!

Update

Remy van Elst recently pushed out a snap version of gnash, you can see his work here: I’ve packaged up Gnash as a snap, for modern linux. All you need to do is:

$ snap install gnash-raymii # install gnash
$ gnash-raymii.gnash filename.swf # use gnash

The setup is much easier than using docker, hats off to Remy!

It's never a network problem, until it is

Mon, 26 Oct 2020 00:00:00 +0000

You know when you have a problem and you struggle to find the solution?

And you just try and try, maybe not even trying some solution because it could never be that THAT part is broken, right? Right?

Well… i struggled with git from within a VM and with a VPN: no git push, spotty git pull. I assumed it was a git problem, or a key problem. No, it was an MTU problem!

Turns out when you hop between increasingly strict networks (virtual switches, vpn, wifi packets, you name it) sometimes fragmentations can’t cope with the whole thing…

So i had to run

sudo ip link set dev eth0 mtu 1400

to lower the MTU and finally being able to operate git.

(sudo ifconfig eth0 mtu 1458 does not work because ubuntu 18+ does not ship with ifconfig)

Viper configuration injection and Airhacks.tv

Sun, 25 Oct 2020 00:00:00 +0000

I had a chance of promoting civitz/viper on Adam Bien’s airhacks.tv series.

You can find the awesome adam bien series on airhacks.tv, and the episode with viper is here:

It turns out developing a large array of tests was appreciated :)

Thanks Adam for reviewing the library!

A note taking system in vscode

Sun, 09 Aug 2020 00:00:00 +0000

I keep all my notes and interesting files in a single directory (e.g. $HOME/documents) and open Visual Studio Code using that directory as base folder.

Now I have

fuzzy search out of the box for files (assuming I have some sort of naming conventions)
a fast full-text search
ready-to-use syntax highlighting for code snippets
rendering for images/gifs

Build github pages with jekyll via docker

Sun, 09 Aug 2020 00:00:00 +0000

Every time I want to write something in my blog, I somehow manage to mess with my ruby/jekyll setup, so I guess it’s time for some docker.

Starting from the awesome work of Hans Kristian Flaatten’s docker github pages, but it lacks draft rendering. Instead of building another image with an hardcoded --drafts parameter, I added an ENTRYPOINT rather than CMD, thus converting the image to a command line jekyll.

I can then run

docker run -t -v "$PWD":/usr/src/app -p "4000:4000" jekyll-gh --drafts

to obtain a working site on localhost:4000 with rendered drafts.

The example command above assumes I ran docker build -t jekyll-gh . to build the image with the jekyll-gh tag.

You can find the Dockerfile in the code home of this blog along with a handy script to run the whole thing.

Openapi/swagger editor from docker

Thu, 20 Feb 2020 00:00:00 +0000

If you need to quickly edit or view a swagger/openapi spec, you can use the mighty swagger editor: https://github.com/swagger-api/swagger-editor

For a quick way to run it, use docker to run the editor itself:

docker pull swaggerapi/swagger-editor
docker run -d -p 8080:8080 swaggerapi/swagger-editor

Then open your browser on localhost to use the webapp.

xdg-open http://127.0.0.1:8080