Nel noto marketplace underground Exploit.in, il threat actor chestniybro ha messo all’asta un accesso RDP a una non meglio identificata azienda italiana operante nel settore retail di gioielli e orologi.

Secondo il post pubblicato dal venditore, l’azienda presenta un fatturato superiore ai 20 milioni di dollari, impiega oltre 250 dipendenti, e protegge la propria infrastruttura con l’antivirus CrowdStrike Falcon, uno dei più noti strumenti EDR in ambito enterprise.

Inoltre, l’infrastruttura tecnica compromessa sarebbe composta da più di 350 host distribuiti su 5 data center, un dato che lascia intuire una realtà aziendale di dimensioni non trascurabili.

L’accesso offerto è di tipo RDP con privilegi di Domain User, il che lo rende potenzialmente utile a gruppi ransomware per movimenti laterali o escalation di privilegi. Il prezzo di partenza dell’asta è 1.000 dollari, con rilanci da 100 e un “Buy Now” a 1.400 dollari.

Non è la prima volta che aziende italiane finiscono nel mirino dei cyber criminali. In passato abbiamo documentato la vendita di accessi simili a realtà dei settori industriale, logistico e sanitario. Tuttavia, l’interesse verso il mondo del retail di fascia alta evidenzia una diversificazione degli obiettivi da parte dei threat actors, forse attratti dal valore dei dati, dalle potenziali frodi finanziarie o dalla capacità di pagare riscatti.

La presenza di una soluzione EDR avanzata come CrowdStrike Falcon non ha impedito la compromissione, il che potrebbe indicare una cattiva configurazione, l’assenza di segmentazione di rete o l’uso di credenziali valide ottenute tramite phishing, infostealer o insider.

Secondo i dati disponibili, l’account chestniybro è attivo dal 2017, ha pubblicato 13 post ed è identificato con il badge “Autogarant 1”, ovvero una vendita andata a buon fine con garanzia del servizio escrow del forum, elemento che potrebbe incentivare l’acquisto da parte di attori ransomware-as-a-service. Degno di nota anche il fatto che, negli ultimi giorni, lo stesso utente ha messo in vendita ben otto accessi analoghi riferiti ad aziende di diversi Paesi, tra cui Stati Uniti e Australia

Questa ennesima vendita di accessi a infrastrutture italiane evidenzia come il mercato dell’inizial access sia ormai una componente chiave dell’ecosistema cyber criminale. Monitorare queste attività, intervenire rapidamente su eventuali segnali di compromissione e rafforzare le difese proattive rimane essenziale per proteggere il tessuto economico nazionale.

L'articolo Preludio al ransomware: In vendita gli accessi a un’azienda italiana del settore retail di gioielli e orologi proviene da il blog della sicurezza informatica.

Negli ultimi due anni ho lavorato principalmente con large language models, occupandomi di training, fine-tuning, prompting e così via, poiché era molto richiesto dal mercato e dagli utenti. Ma credo che gli LLM che lavorano principalmente con il testo siano solo l’inizio della GenAI. A un certo punto, tutti vorranno un’AI fisica, in cui i modelli possano vedere, sentire, percepire e ragionare in modo più concreto e umano.

Quindi iniziamo con la multimodalità. In questo notebook introduco LLaVA, un’architettura in grado di interpretare sia immagini che testo per generare risposte multimodali.

In questo tutorial utilizzeremo componenti più leggeri, adatti a far girare il notebook in un ambiente gratuito come Google Colab.

I componenti che utilizzeremo sono:

1️⃣ CLIP-ViT B/32 come image encoder
2️⃣ TinyLlama-1.1B come language model
3️⃣ Un MLP adapter a 2 layer per collegare i due modelli

Dal paper Visual Instruction Tuning (NeurIPS 2023)

Setup

Prima di inziare a scrivere codice dobbiamo creare il nostro environment.

Installiamo e importiamo le librerie necessarie.

!pip install -U datasets

import json
from pathlib import Path

import requests
import safetensors
import torch
from datasets import load_dataset
from huggingface_hub import hf_hub_download
from PIL import Image
from transformers import (
AutoConfig,
AutoTokenizer,
LlamaTokenizer,
LlavaConfig,
LlavaForConditionalGeneration,
LlavaProcessor,
Seq2SeqTrainer,
Seq2SeqTrainingArguments,
)
from transformers.models.clip.modeling_clip import CLIPVisionModel
from transformers.models.clip.image_processing_clip import CLIPImageProcessor

Download dei componenti pre-addestrati

Il nostro modello LLaVA sarà composto da :

• Un encoder pre-addestrato CLIP openai/clip-vit-base-patch32

• Un decoder pre-addestrato Tiny LLaMA TinyLlama/TinyLlama-1.1B-Chat-v1.0
• Due layer MLP tra i due che usiamo per il mapping delle dimensioni

vision_backbone_name = "openai/clip-vit-base-patch32"
text_backbone_name = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"

_ = hf_hub_download(
vision_backbone_name, filename="pytorch_model.bin", local_dir="/content"
)
_ = hf_hub_download(
text_backbone_name, filename="model.safetensors", local_dir="/content"
)

Modello

Instanziamo un nuovo modello LLaVA

vision_config = AutoConfig.from_pretrained(vision_backbone_name).vision_config
text_config = AutoConfig.from_pretrained(text_backbone_name)

llava_config = LlavaConfig(vision_config=vision_config, text_config=text_config)

model = LlavaForConditionalGeneration(llava_config).cuda()

model

E’ ora di fare qualche modifica interna al nostro modello

In precedenza abbiamo detto che è possibile costruire un modello LLaVA partendo da un image encoder pre-addestrato e un LLM pre-addestrato. Facciamolo davvero!

Il modello originale di LLaVA è inizializzato a partire da un CLIP-ViT L/14 e un Vicuna v1.5 7B. Per rendere il tutto più gestibile con le risorse offerte dal piano gratuito di Google Colab, utilizzeremo invece un CLIP-ViT B/16 e un TinyLlama 1.1B.

L’unico componente che addestreremo sarà un MLP adapter a 2 layer che collega i due modelli.

def load_weights(path_to_weights: str):
if path_to_weights.endswith(".safetensors"):
return load_safetensors_weights(path_to_weights)
elif path_to_weights.endswith(".bin"):
return load_bin_weights(path_to_weights)
else:
raise ValueError(f"Unsupported weights file: {path_to_weights}")

def load_bin_weights(path_to_weights: str):
return torch.load(path_to_weights, weights_only=True)

def load_safetensors_weights(path_to_weights: str):
return safetensors.torch.load_file(path_to_weights)

vision_backbone_state_dict = load_weights("/content/pytorch_model.bin")
text_backbone_state_dict = load_weights("/content/model.safetensors")

Iniettiamo i pesi del vision backbone nel modello 💉

incompatible_keys = model.vision_tower.load_state_dict(
vision_backbone_state_dict, strict=False
)

assert len(incompatible_keys.missing_keys) == 0, (
f"Missing keys in state dict: {incompatible_keys.missing_keys}"
)

incompatible_keys.unexpected_keys

Iniettiamo i pesi del text backbone nel modello 💉

incompatible_keys = model.language_model.load_state_dict(
text_backbone_state_dict, strict=True
)

Congeliamo i componenti pre-addestrati ❄️

_ = model.vision_tower.requires_grad_(False)
_ = model.language_model.requires_grad_(False)

def count_parameters(model, trainable_only=False):
return sum(
p.numel()
for p in model.parameters()
if not trainable_only or p.requires_grad
)

print(f"Total parameters: {count_parameters(model)}")
print(f"Trainable parameters: {count_parameters(model, trainable_only=True)}")

Processor

tokenizer = LlamaTokenizer.from_pretrained(
text_backbone_name, additional_special_tokens=["", ""]
)
tokenizer.pad_token_id = 32001

Qui sotto è mostrato il formato che useremo per interagire con il nostro modello LLaVA.

La prima parte è il cosiddetto system prompt, che contiene linee guida generali su come il modello dovrebbe rispondere all’utente.

La seconda parte è un Jinja template (fondamentalmente codice) che determina come viene resa la conversazione a partire da un input strutturato (vedi esempio sotto).

LLAVA_CHAT_TEMPLATE = (
"A chat between a curious user and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions. "
"{% for message in messages %}{% if message['role'] == 'user' %}USER: {% else %}ASSISTANT: {% endif %}{% for item in message['content'] %}{% if item['type'] == 'text' %}{{ item['text'] }}{% elif item['type'] == 'image' %}{% endif %}{% endfor %}{% if message['role'] == 'user' %} {% else %}{{eos_token}}{% endif %}{% endfor %}"
)
tokenizer.chat_template = LLAVA_CHAT_TEMPLATE

sample_messages = [
{
"content": [
{
"index": 0,
"text": None,
"type": "image"
},
{
"index": None,
"text": "\nWhat potential activities might be popular at this location?",
"type": "text"
}
],
"role": "user"
},
{
"content": [
{
"index": None,
"text": (
"At this location, with a sandy path leading to the ocean where multiple boats, including "
"sailboats, are moored, popular activities might include boating, sailing, swimming, and "
"beachcombing. Additionally, the sandy path and shoreline provide an ideal setting for leisurely "
"strolls and picnics, while the ocean view offers a serene environment for relaxation and "
"photography. Depending on the specific area and available facilities, other water sports such as "
"kayaking, paddleboarding, and snorkeling could also be prevalent."
),
"type": "text"
}
],
"role": "assistant"
}
]

tokenizer.apply_chat_template(
sample_messages, tokenize=False, add_generation_prompt=False
)

processor = LlavaProcessor(
image_processor=CLIPImageProcessor.from_pretrained(vision_backbone_name),
tokenizer=tokenizer,
patch_size=model.config.vision_config.patch_size,
)
processor.chat_template = LLAVA_CHAT_TEMPLATE

model.resize_token_embeddings(len(tokenizer), pad_to_multiple_of=8)

Dataset

train_dataset = load_dataset(
"HuggingFaceH4/llava-instruct-mix-vsft", split="train", streaming=True
)

Come sono fatti in nostri dati di training?

next(iter(train_dataset))

Come creiamo un batch di esempio?

def get_data_collator(processor, ignore_index):
def collate_examples(examples):
# Extract texts and images from the raw examples
texts =
[] images =
[] for example in examples:
messages = example["messages"]
text = processor.tokenizer.apply_chat_template(
messages, tokenize=False, add_generation_prompt=False
)
texts.append(text)
images.append(example["images"][0])

# Process the inputs (tokenize text and transform images)
batch = processor(texts, images, return_tensors="pt", padding=True)

# Create labels
labels = batch["input_ids"].clone()
if processor.tokenizer.pad_token_id is not None:
labels[labels == processor.tokenizer.pad_token_id] = ignore_index
batch["labels"] = labels

return batch

return collate_examples

# NOTE: this does a bit more than a collate function should...

Training

args = Seq2SeqTrainingArguments(
output_dir="/content/training_output",
per_device_train_batch_size=2,
gradient_accumulation_steps=4,
learning_rate=2e-4,
max_steps=350,
lr_scheduler_type="cosine_with_min_lr",
lr_scheduler_kwargs={"min_lr": 2e-5},
warmup_ratio=0.05,
logging_strategy="steps",
logging_steps=5,
fp16=True,
remove_unused_columns=False, # Important!
optim="adamw_torch",
report_to="none",
save_strategy="no", # let's not save the checkpoint to disk, otherwise it'll take 5 mins
)

trainer = Seq2SeqTrainer(
model=model,
args=args,
data_collator=get_data_collator(
processor, ignore_index=model.config.ignore_index,
),
train_dataset=train_dataset,
)

trainer.train()

Inferenza

È importante notare che, per garantire che l’inferenza funzioni come previsto, bisognerebbe utilizzare modelli più pesanti e addestrare per un periodo di tempo più lungo.

Useremo questa immagine per l’inferenza:

conversation = [
{
"content": [
{
"type": "image"
},
{
"text": "\nWhat is represented in the image?",
"type": "text"
}
],
"role": "user"
}
]

image_url = "https://llava-vl.github.io/static/images/monalisa.jpg"

inputs_for_generation = processor(
images=Image.open(requests.get(image_url, stream=True).raw),
text=processor.apply_chat_template(conversation, add_generation_prompt=True),
return_tensors="pt",
)

inputs_for_generation = inputs_for_generation.to(device=model.device)
output = trainer.model.generate(
**inputs_for_generation, max_new_tokens=200, do_sample=False
)

print(processor.decode(output[0], skip_special_tokens=True))

Miglioramenti possibili

• Utilizza un image encoder più grande (es. CLIP-ViT Large) e un LLM più potente (es. Llama 3.1 8B)
• Allena il modello più a lungo. Serve tempo affinché il modello impari a seguire le istruzioni in presenza di image features
• Segui la procedura di addestramento multi-stadio adottata dal LLaVA originale:
  
  • Stage 1: Pre-training for Feature Alignment → addestra il modello su dati di istruzioni a singola interazione, dove viene chiesto di descrivere brevemente l’immagine. Image encoder e LLM sono congelati ❄️
  • Stage 2: Fine-tuning End-to-End → addestra il modello su dati di istruzioni multi-turno. Solo l’image encoder rimane congelato ❄️

  
  

🔗 Demo funzionante: huggingface.co/spaces/badayvedat/LLaVA

Conclusioni

Penso che questo piccolo progetto sia interessante per capire meglio come funzionano i modelli multimodali come LLaVA. Anche se abbiamo utilizzato modelli più piccoli, l’idea principale rimane la stessa: combinare visione e linguaggio in un unico sistema capace di comprendere le immagini e parlarne.

Ovviamente, i risultati ottenuti in questo toy example non sono particolarmente buoni, c’è molto margine di miglioramento. Ma far funzionare LLaVA in un ambiente con risorse limitate è già di per sé una bella sfida.

L'articolo Implementazione di Modelli Multimodali con LLaVA proviene da il blog della sicurezza informatica.

Even if you don’t cast or forge metal yourself, you’re probably aware that you need to get the material very, very hot to make that happen. While some smiths might still stoke coal fires, that’s a minority taste these days; most, like [mikeandmertle] use gas burners to generate the heat. Tired of expensive burners or finicky DIY options [mikeandmertle] built their own Better Burner out of easily-available parts.

Everything you need to make this burner comes from the hardware store: threaded iron pipes of various sizes, hoses and adapters– except for one key piece: a 3D printer nozzle. The nozzle is used here as the all-important gas jet that introduces flammable gas into the burner’s mixing chamber. A demo video below shows it running with a 0.3mm nozzle, which looks like it is putting out some serious heat, but [mikeandmertle] found that could go out if the breather was opened too wide (allowing too much air in the mixture). Eventually he settled on a 0.4mm nozzle, at least for the LPG that is common down under. If one was to try this with propane, their mileage would differ.

That’s the great thing about using printer nozzles, though: with a tapped M6 hole on the cap of the gas pipe serving as intake, one can quickly and easily swap jets without worrying about re-boring. Printer nozzles are machined to reasonable accuracy and you can get a variety pack with all available sizes (including ones so small you’re probably better off using resin) very cheaply.

These sorts of use-what-you-have-on-hand hacks seem to be [mikeandmertle]’s specialty– we’ve seen their PVC thumb nut and their very simple mostly-wooden wood lathe here before.

youtube.com/embed/SpwoR4yHE8U?…

hackaday.com/2025/06/18/gas-bu…

Due gravi vulnerabilità di sicurezza sono state individuate nei dispositivi NetScaler ADC e NetScaler Gateway (precedentemente noti come Citrix ADC e Gateway). Queste falle possono permettere a un attaccante di accedere a dati sensibili e compromettere l’infrastruttura di rete aziendale.

Il Cloud Software Group, sviluppatore di queste soluzioni, ha diffuso un avviso urgente invitando tutti i clienti ad aggiornare immediatamente i dispositivi interessati. Le vulnerabilità, catalogate come CVE-2025-5349 e CVE-2025-5777, hanno ricevuto punteggi CVSS di 8,7 e 9,3, indicando un livello di rischio critico.

Le vulnerabilità sono state scoperte tramite divulgazione responsabile da parte dei ricercatori di sicurezza di Positive Technologies e ITA MOD CERT (CERTDIFESA), che hanno collaborato con Cloud Software Group per proteggere i clienti prima della divulgazione al pubblico.

Cloud Software Group raccomanda vivamente ai clienti interessati di installare immediatamente le versioni aggiornate. L’azienda ha rilasciato versioni patchate, tra cui NetScaler ADC e Gateway 14.1-43.56, la versione 13.1-58.32 e i relativi aggiornamenti conformi allo standard FIPS.

Le falle di sicurezza interessano numerose versioni dei prodotti NetScaler attualmente in uso presso organizzazioni in tutto il mondo. Tra i sistemi vulnerabili figurano le versioni 14.1 (precedente alla 14.1-43.56) di NetScaler ADC e Gateway, la versione 13.1 (precedente alla 13.1-58.32) e diverse versioni conformi allo standard FIPS.

Particolarmente preoccupante è il fatto che le versioni 12.1 e 13.0 di NetScaler, ora designate come End of Life (EOL), rimangano vulnerabili e non siano disponibili patch di sicurezza. Anche le organizzazioni che utilizzano Secure Private Access in distribuzioni on-premise o ibride con istanze NetScaler sono a rischio e devono aggiornare immediatamente i propri sistemi.

Dopo il processo di aggiornamento, gli amministratori devono eseguire comandi specifici per terminare tutte le sessioni ICA e PCoIP attive su tutte le appliance NetScaler in coppie o cluster ad alta disponibilità. Ciò garantisce una protezione completa contro potenziali tentativi di exploit.

Le organizzazioni che utilizzano l’infrastruttura NetScaler dovrebbero dare priorità a questi aggiornamenti, data la natura critica di queste vulnerabilità e il loro potenziale di consentire l’accesso non autorizzato a dati aziendali sensibili e risorse di rete.

L'articolo Allarme NetScaler ADC e Gateway: Due bug gravi mettono a rischio le aziende in tutto il mondo proviene da il blog della sicurezza informatica.

There’s a famous old story about [Charles Steinmetz] fixing a generator for [Henry Ford]. He charged a lot of money for putting a chalk X in the spot that needed repair. When [Ford] asked for an itemization, the bill read $1 for the chalk, and the balance for knowing where to draw the X. With today’s PCB layout tools, it seems easy to put components down on a board. But, as [Kasyan TV] points out in the video below, you still have to know where to put them.

The subject components are inductors, which are particularly picky about placement, especially if you have multiple inductors. After all, inductors affect one another — that’s how transformers work. So there are definite rules about good and bad ways to put a few inductors on a board.

However, in the video, air-core coils go through several orientations to see which configuration has the most and least interference. Using a ferrite core showed similar results. The final examples use toroids and shielded inductors.

One reason ferrite toroids are popular in radio designs is that coils made this way are largely self-shielding. This makes placement easier and means you don’t need metal “cans” to shield the inductors. How much do they shield? The orientation makes a little difference, but not by much. It is more important to give them a little space between the coils. Shields work, too, but note that they also change the inductance value.

While we like the idea of grabbing a breadboard and a scope to measure things, we want to point out that you can also simulate. If you didn’t understand the title, you probably don’t listen to Propellerheads.

youtube.com/embed/VhruG2Hu7iY?…

hackaday.com/2025/06/18/a-numb…

La povertà aumenta, in Italia, in Europa.
Ovunque.
Togliere la dignità alle persone sembra l'idea di molti Governi.

noblogo.org/transit/povero-fut…

Transit

2025-06-18 12:27:41

Povero futuro.

(169)

Nota: questo sarà un post noioso, ma, a volte, le aride cifre fotografano nitidamente le situazioni, anche quelle molto grandi, anche quelle che dentro hanno milioni di persone. D’altro canto sono certo che chiunque vorrà leggere queste righe sa comprendere benissimo numeri e percentuali. Altrimenti sarebbe un guaio.

Nel corso del 2024, l’Italia ha registrato un aggravamento significativo sia della #povertà assoluta sia di quella relativa, alla luce di dati ufficiali e referti della società civile. Secondo l’ultimo rapporto ISTAT e della “Caritas”, la quota di persone in condizione di povertà assoluta ha raggiunto il 9,7 %, pari a circa 5,6–5,7 milioni di individui, corrispondente a circa 2,2 milioni di famiglie. Lo stesso rapporto segnala come la povertà assoluta, benché stabile tra il 2022 e il 2023, risulti al livello più elevato dell’ultimo decennio, con una progressione costante dal 2014 (dal 6,9 % al 9,7 %) per quanto riguarda le persone.

Sul versante della povertà relativa, si evidenzia un ulteriore peggioramento: nel 2023 le famiglie colpite dal fenomeno superavano i 2,8 milioni (10,6 %) e le persone in difficoltà ammontavano a 8,4 milioni (14,5 %). Parallelamente, l’Eurostat stima che nel 2024 il 23,1 % degli italiani – circa 13,5 milioni – viva in condizioni di rischio di povertà o esclusione sociale, con aumenti particolarmente allarmanti per quanto riguarda i minori e le persone over 60.

A questi numeri drammatici si accompagna la crescita del fenomeno dei “Working poor”: in Italia il 21 % dei lavoratori percepisce un reddito insufficiente per condurre una vita dignitosa, con una situazione che colpisce in modo particolarmente intenso le classi operaie (tra le quali la povertà assoluta ha superato il 16,5 %) e i 35-54enni, oltre il 30 % dei quali non riesce a evitare uno stato di indigenza.

Tale contesto si dispiega in un quadro di politiche pubbliche inadeguate: le misure statali di contrasto alla povertà — dal “reddito di inclusione” alla spesa sociale — risultano insufficienti e, in molti casi, inefficaci. Nonostante il “Reddito di cittadinanza” abbia avuto un impatto importante, ben il 56 % delle persone povere non lo ha percepito, per cause che vanno dai problemi di residenza alla burocrazia. Le politiche di welfare restano lacunose e non affrontano adeguatamente la questione del “lavoro povero”, né investono in una rete di protezione robusta per le famiglie vulnerabili.

Questa fragilità sociale si inserisce in un contesto europeo che appare sempre più orientato verso la militarizzazione. Il “ReArm Europe – Readiness 2030”, lanciato a marzo 2025 dalla Commissione UE, punta a mobilitare fino a 800 miliardi di euro in spese per la difesa, tra aumenti delle spese nazionali, fondi comuni e prestiti SAFE da 150 miliardi, con la possibilità di dirottare risorse dai fondi di coesione e sostenibilità. Secondo le ultime stime, per colmare il gap militare si dovrebbe arrivare a investire fino al 5 % del PIL, una cifra che in Francia, Regno Unito e in molti altri Paesi corrisponde all’intero ammontare delle loro politiche di welfare e di protezione sociale. Analisti economici sottolineano che una simile quantità di risorse sarà sottratta a capitoli cruciali per combattere la povertà, rafforzare l’istruzione, la sanità e l’inclusione sociale, aumentando di conseguenza le disuguaglianze e l’emarginazione delle fasce più deboli.

La convergenza tra crisi del reddito, insufficienza delle politiche sociali e spinta europea verso spese militari aggressive aggrava la condizione dei più deboli. Se non si rivedono le priorità — affiancando politiche attive per il lavoro, la dignità universale del reddito e un welfare veramente inclusivo — il rischio è quello di lasciare milioni di cittadini italiani ed europei in una situazione di esclusione sempre più profonda.

Ma, forse, è proprio questo lo scopo ultimo di tutta questa sequela di mancanze, di tutti i soldi che non andranno ad aiutare le persone, soprattutto quelle povere, emarginate, fastidiose: la loro eliminazione. Se non fisica (almeno lo spero), almeno dalla vita pubblica, dalla società. Relegare coloro che non possono più permettersi la dignità sarebbe un ottimo viatico alla dittatura totale del liberismo, dell’effimero, del domani concesso solo a chi i soldi li ha e non viene disturbato da Governi sempre più distanti da una minima idea di democrazia.Se il futuro deve ancora essere scritto, non può diventare così. Non dovrebbe permetterlo nessuno, mai.

#Blog #Italia #ReArmEurope #UE #Società #Povertà #Society #Poverty #Opinioni #Opinions

Mastodon: @alda7069@mastodon.unoTelegram: t.me/transitblogFriendica: @danmatt@poliverso.orgBio Site (tutto in un posto solo, diamine): bio.site/danielemattioli

Gli scritti sono tutelati da “Creative Commons” (qui)

Tutte le opinioni qui riportate sono da considerarsi personali. Per eventuali problemi riscontrati con i testi, si prega di scrivere a: corubomatt@gmail.com

Transit

Il blog di Alessandra Corubolo & Daniele Mattioli. On line -in varie forme- dal 2005.

^Telegram

Ieri è scaduto il mio contratto di lavoro.
Settimana scorsa mi è stato detto che me l'avrebbero prolungato fino a marzo 2026, con una percentuale lavorativa del 80%. Per me va bene.
Nonostante diverse sollecitazioni da parte mia (e a diversi livelli) non ho ancora ricevuto il nuovo contratto. E, d'accordo col mio superiore, oggi non mi sono presentata al lavoro. Domani è festivo in Ticino. Venerdì cosa farò?

Per il resto è ancora tutto difficile.. problemi di salute (non miei), problemi familiari, problemi con l'appartamento, ... 😱

Stavamo pianificando le vacanze di agosto, ma aspetto il contratto.

Ce la faremo 💪🏼

#lavoro #contratto #Stato #vacanze