fileIdField.setAccessible(true);
            fileIdField.set(notification, fileId);

            String result = notification.toString();

            // Note: There's a typo in the original code - "Opblock" instead of "Oplock"
            assertTrue(result.startsWith("Smb2OpblockBreakNotification["));
            assertTrue(result.contains("oplockLevel=" + oplockLevel));

        String ip = "192.168.1.7";

        // Block the IP
        for (int i = 1; i <= 5; i++) {
            assertTrue(rateLimiter.checkAttempt("user" + i, ip));
            rateLimiter.recordFailure("user" + i, ip);
        }

        // Should be blocked
        assertFalse(rateLimiter.checkAttempt("user6", ip), "IP should be blocked");

        // Manually unblock

            log.info("Manually unlocked account: {}", username);
            return true;
        }
        return false;
    }

    /**
     * Manually unblock an IP
     *
     * @param sourceIp the IP to unblock
     * @return true if IP was unblocked, false if not found
     */
    public boolean unblockIp(String sourceIp) {
        IpAttempts ip = ipAttempts.get(sourceIp);

## Implementation Phases

### Phase 1: SMB3 Lease Implementation (Foundation)
**Priority: HIGH** | **Estimated Effort: 3-4 weeks**

SMB3 leases replace the traditional oplock mechanism and are foundational for other features.

#### 1.1 Core Lease Infrastructure
```
Package: jcifs.internal.smb2.lease
├── Smb2LeaseBreak.java          - Lease break notification handling

        DummyAndXBlock block = new DummyAndXBlock(next);

        assertNotNull(block);
        assertSame(next, block.andx, "andx should reference provided SMB");
    }

    @Test
    @DisplayName("getBatchLimit defaults to 0")
    void testGetBatchLimitDefault() {
        DummyAndXBlock block = new DummyAndXBlock();
        assertEquals(0, block.getBatchLimit((byte) 0x25));
    }

    @Test

    /**
     * No oplock
     */
    public static final byte SMB2_OPLOCK_LEVEL_NONE = 0x0;
    /**
     * Level II oplock
     */
    public static final byte SMB2_OPLOCK_LEVEL_II = 0x1;
    /**
     * Exclusive oplock
     */
    public static final byte SMB2_OPLOCK_LEVEL_EXCLUSIVE = 0x8;
    /**
     * Batch oplock
     */

        length -= remainder;
        int block;
        int i = 0;
        while (i < length) {
            block = (bytes[i++] & 0xff) << 16 | (bytes[i++] & 0xff) << 8 | bytes[i++] & 0xff;
            buffer.append(ALPHABET.charAt(block >>> 18));
            buffer.append(ALPHABET.charAt(block >>> 12 & 0x3f));
            buffer.append(ALPHABET.charAt(block >>> 6 & 0x3f));
            buffer.append(ALPHABET.charAt(block & 0x3f));

        <span class="sponsor-badge">sponsor</span>
        <img class="sponsor-image" src="/img/sponsors/blockbee-banner.png" />
      </a>
    </div>
    <div class="item">

    }

    /// Encrypt a block of bytes.
    /**
     * Encrypts an 8-byte block using DES
     * @param clearText the 8-byte plaintext block
     * @param cipherText the output 8-byte ciphertext block
     */
    public void encrypt(final byte[] clearText, final byte[] cipherText) {
        encrypt(clearText, 0, cipherText, 0);
    }

    /// Decrypt a block of bytes.
    /**

     *    <p>
     *    Transforms context based on 512 bits from input block starting
     *    from the offset'th byte.
     *
     *    @param    block    input sub-array.
     *    @param    offset    starting position of sub-array.
     */
    private void transform(final byte[] block, int offset) {

        // encodes 64 bytes from input block into an array of 16 32-bit
        // entities. Use A as a temp var.