Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Strumenti/GitHubGitHub/nichetoolkit/spring-retry-toolkit
Analisi delle VulnerabilitàSicurezza WebSicurezza della Supply Chain
GitHubnichetoolkit/spring-retry-toolkit

spring-retry-toolkit

fix per spring retry 1.3.x con toolkit di nicchia per CVE-2026-41710

Vedi Repository
343 mesi faNon ancora revisionato
Condividi

Javadocs

Questo progetto fornisce supporto al retry dichiarativo per le applicazioni Spring. È utilizzato in Spring Batch, Spring Integration e altri. È inoltre supportato il retry imperativo per un utilizzo esplicito.

Versione

La versione corregge spring-retry con la 2.0.13 per java8 e spring4 o spring5, Per maggiori informazioni, fare riferimento alla versione ufficiale Spring 2.0.13

Avvio rapido

Questa sezione fornisce una rapida introduzione per iniziare con Spring Retry. Include un esempio dichiarativo e un esempio imperativo.

Esempio dichiarativo

Il seguente esempio mostra come utilizzare Spring Retry nello stile dichiarativo:

@Configuration
@EnableRetry
public class Application {

    @Bean
    public Service service() {
        return new Service();
    }

}

@Service
class Service {
    @Retryable(RemoteAccessException.class)
    public void service() {
        // ... do something
    }
    @Recover
    public void recover(RemoteAccessException e) {
       // ... panic
    }
}

Questo esempio chiama il metodo service e, se fallisce con una RemoteAccessException, riprova (per impostazione predefinita, fino a tre volte), e poi prova il metodo recover se non ha successo. Ci sono varie opzioni negli attributi dell'annotazione @Retryable per includere ed escludere tipi di eccezione, limitare il numero di tentativi e impostare la politica di backoff.

L'approccio dichiarativo all'applicazione della gestione dei tentativi tramite l'annotazione @Retryable mostrata in precedenza ha una dipendenza aggiuntiva a runtime dalle classi AOP. Per i dettagli su come risolvere questa dipendenza nel tuo progetto, consulta la sezione 'Java Configuration for Retry Proxies'.

Esempio imperativo

Il seguente esempio mostra come utilizzare Spring Retry nel suo stile imperativo (disponibile dalla versione 1.3):

RetryTemplate template = RetryTemplate.builder()
				.maxAttempts(3)
				.fixedBackoff(1000)
				.retryOn(RemoteAccessException.class)
				.build();

template.execute(ctx -> {
    // ... do something
});

Per le versioni precedenti alla 1.3, vedere gli esempi nella sezione RetryTemplate.

Compilazione

Spring Retry richiede Java 1.7 e Maven 3.0.5 (o superiore). Per compilare, eseguire il seguente comando Maven:

$ mvn install

Funzionalità e API

Questa sezione illustra le funzionalità di Spring Retry e mostra come utilizzare la sua API.

Utilizzo di RetryTemplate

Per rendere l'elaborazione più robusta e meno soggetta a errori, a volte è utile ritentare automaticamente un'operazione fallita, nel caso in cui possa riuscire in un tentativo successivo. Gli errori suscettibili a questo tipo di trattamento sono di natura transitoria. Ad esempio, una chiamata remota a un servizio web o a un servizio RMI che fallisce a causa di un problema di rete o di una DeadLockLoserException in un aggiornamento del database può risolversi dopo una breve attesa. Per automatizzare il nuovo tentativo di tali operazioni, Spring Retry dispone della strategia RetryOperations. La definizione dell'interfaccia RetryOperations è la seguente:

public interface RetryOperations {

    <T> T execute(RetryCallback<T> retryCallback) throws Exception;

    <T> T execute(RetryCallback<T> retryCallback, RecoveryCallback<T> recoveryCallback)
        throws Exception;

    <T> T execute(RetryCallback<T> retryCallback, RetryState retryState)
        throws Exception, ExhaustedRetryException;

    <T> T execute(RetryCallback<T> retryCallback, RecoveryCallback<T> recoveryCallback,
        RetryState retryState) throws Exception;

}

La callback di base è un'interfaccia semplice che consente di inserire una logica di business da ritentare:

public interface RetryCallback<T> {

    T doWithRetry(RetryContext context) throws Throwable;

}

Il callback viene tentato e, se fallisce (generando un'Exception), viene ritentato finché non ha successo o finché l'implementazione decide di interrompere. Esistono diversi metodi execute sovraccaricati nell'interfaccia RetryOperations, per gestire vari casi d'uso di recupero quando tutti i tentativi di retry sono esauriti e per gestire lo stato di retry, che consente ai client e alle implementazioni di memorizzare informazioni tra le chiamate (ne parleremo più avanti).

L'implementazione generale più semplice di RetryOperations è RetryTemplate. L'esempio seguente mostra come utilizzarla:

RetryTemplate template = new RetryTemplate();

TimeoutRetryPolicy policy = new TimeoutRetryPolicy();
policy.setTimeout(30000L);

template.setRetryPolicy(policy);

Foo result = template.execute(new RetryCallback<Foo>() {

    public Foo doWithRetry(RetryContext context) {
        // Do stuff that might fail, e.g. webservice operation
        return result;
    }

});

Nell'esempio precedente, eseguiamo una chiamata a un servizio web e restituiamo il risultato all'utente. Se tale chiamata fallisce, viene ritentata fino al raggiungimento di un timeout.

Dalla versione 1.3, è disponibile anche la configurazione fluente di RetryTemplate, come segue:

RetryTemplate.builder()
      .maxAttempts(10)
      .exponentialBackoff(100, 2, 10000)
      .retryOn(IOException.class)
      .traversingCauses()
      .build();

RetryTemplate.builder()
      .fixedBackoff(10)
      .withinMillis(3000)
      .build();

RetryTemplate.builder()
      .infiniteRetry()
      .retryOn(IOException.class)
      .uniformRandomBackoff(1000, 3000)
      .build();

Utilizzo di RetryContext

Il parametro del metodo per RetryCallback è un RetryContext. Molti callback ignorano il contesto. Tuttavia, se necessario, è possibile utilizzarlo come contenitore di attributi per memorizzare dati per la durata dell'iterazione.

Un RetryContext ha un contesto padre se è in corso un retry annidato nello stesso thread. Il contesto padre è talvolta utile per memorizzare dati che devono essere condivisi tra le chiamate a execute.

Utilizzo di RecoveryCallback

Quando i tentativi di retry sono esauriti, RetryOperations può passare il controllo a un diverso callback: RecoveryCallback. Per utilizzare questa funzionalità, i client possono passare i callback insieme allo stesso metodo, come mostra l'esempio seguente:

Foo foo = template.execute(new RetryCallback<Foo>() {
    public Foo doWithRetry(RetryContext context) {
        // business logic here
    },
  new RecoveryCallback<Foo>() {
    Foo recover(RetryContext context) throws Exception {
          // recover logic here
    }
});

Se la logica di business non ha successo prima che il template decida di interrompere, al client viene data la possibilità di eseguire un'elaborazione alternativa tramite il callback di recovery.

Retry senza stato

Nel caso più semplice, un retry è solo un ciclo while: il RetryTemplate può continuare a tentare finché non riesce o fallisce. Il RetryContext contiene uno stato per determinare se ritentare o interrompere. Tuttavia, questo stato si trova sullo stack e non c'è bisogno di memorizzarlo globalmente. Di conseguenza, lo chiamiamo "retry senza stato". La distinzione tra retry senza stato e con stato è contenuta nell'implementazione di RetryPolicy (RetryTemplate può gestire entrambi). In un retry senza stato, il callback viene sempre eseguito nello stesso thread in cui è fallito al momento del retry.

Retry con stato

Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    732
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    506
  • 3

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    405
  • 4

    redforge

    cybersecurity91/redforge

    Toolkit red team lato browser con 102 strumenti offline per ricognizione, generazione di payload, attacchi alle credenziali, crittografia, codifica e reportistica dell'engagement.

    342
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Il sistema d'azione per la cybersecurity nativa AI—dove l'intento diventa esecuzione governata, le evidenze diventano memoria operativa, e ogni operazione migliora la successiva.

    261
  • 6

    antifox

    antifox-ai/antifox

    Piattaforma multi-agente di penetration testing autonoma basata sull'IA che esegue ricognizione, scoperta della superficie d'attacco, validazione dello sfruttamento e consegna di report supportati da evidenze.

    259

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →