"type":       "stop",

ad
al
allo
ai
agli
all
agl
alla
alle
con
col
coi
da
dal
dallo
dai
dagli
dall
dagl
dalla
dalle
di
del
dello
dei
degli
dell
degl
della
delle
in
nel
nello
nei
negli
nell
negl
nella
nelle
su
sul
sullo
sui

        }

        @Test
        @DisplayName("Should return salt correctly")
        void testGetSalt() {
            int[] hashAlgos = { 0x01 };
            byte[] salt = { 0x01, 0x02, 0x03, 0x04 };
            PreauthIntegrityNegotiateContext context = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);

            assertArrayEquals(salt, context.getSalt());

        }
        if (salt == null || salt.length != SALT_SIZE) {
            throw new IllegalArgumentException("Invalid salt");
        }

        this.salt = salt.clone();
        this.masterKey = deriveKey(masterPassword, this.salt);

        // Clear the master password after use
        Arrays.fill(masterPassword, '\0');
    }

            byte[] buffer = new byte[] { 0x02, 0x00, // 2 hash algos
                    0x04, 0x00, // 4 bytes salt
                    0x01, 0x00, // SHA512
                    0x02, 0x00, // Another hash algo
                    0x0A, 0x0B, 0x0C, 0x0D // Salt
            };

            // Act
            int decodedSize = context.decode(buffer, 0, buffer.length);

            // Assert

        this.hashAlgos = hashAlgos;
        this.salt = salt;
    }

    /**
     * Default constructor for deserialization.
     */
    public PreauthIntegrityNegotiateContext() {
    }

    /**
     * Gets the salt value used for preauth integrity.
     *
     * @return the salt
     */
    public byte[] getSalt() {
        return this.salt;
    }

    /**

        String sessionId = "test-session-1";
        byte[] salt = preauthService.generatePreauthSalt();

        PreauthIntegrityContext context = preauthService.initializeSession(sessionId, salt, PreauthIntegrityService.HASH_ALGO_SHA512);

        assertNotNull(context);
        assertEquals(PreauthIntegrityService.HASH_ALGO_SHA512, context.getHashAlgorithm());
        assertArrayEquals(salt, context.getSalt());
        assertTrue(context.isValid());

    }

    /**
     * Generates a new preauth salt for SMB 3.1.1 negotiation.
     *
     * @return a cryptographically secure random salt
     */
    public byte[] generatePreauthSalt() {
        byte[] salt = new byte[SALT_SIZE];
        secureRandom.nextBytes(salt);
        log.debug("Generated new preauth salt of {} bytes", salt.length);
        return salt;
    }

    /**

            int[] hashAlgos = { 1, 2 };
            byte[] salt = new byte[8];
            Arrays.fill(salt, (byte) 0xFF);

            context = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);

            // Encode at position 100
            int encoded = context.encode(buffer, 100);
            assertEquals(context.size(), encoded);

            // Verify salt is at correct position

            final byte[] salt = new byte[32];
            config.getRandom().nextBytes(salt);
            negoContexts.add(
                    new PreauthIntegrityNegotiateContext(config, new int[] { PreauthIntegrityNegotiateContext.HASH_ALGO_SHA512 }, salt));
            this.preauthSalt = salt;

            if (config.isEncryptionEnabled()) {