when(mockMd5.digest()).thenReturn(innerDigest);
            when(mockMd5.digest(any(byte[].class))).thenReturn(finalDigest);

            HMACT64 hmac = new HMACT64(TEST_KEY);
            byte[] result = hmac.engineDigest();

            assertArrayEquals(finalDigest, result);
            verify(mockMd5, times(1)).digest(); // First call for inner digest

        }
        this.digest.update(input, offset, len);
        this.updates++;
    }

    /**
     * Finalize and return the calculated message digest
     *
     * @return calculated digest
     */
    public byte[] digest() {
        byte[] b = this.digest.digest();

        if (log.isTraceEnabled()) {
            log.trace("digest: ");

        // Given
        byte[] data = input.getBytes();

        // When
        MessageDigest md4 = Crypto.getMD4();
        MessageDigest md5 = Crypto.getMD5();
        byte[] md4Hash = md4.digest(data);
        byte[] md5Hash = md5.digest(data);

        // Then
        assertNotNull(md4Hash);
        assertNotNull(md5Hash);
        assertEquals(16, md4Hash.length);
        assertEquals(16, md5Hash.length);
    }

        assertDoesNotThrow(() -> digest.update(data, 0, 0));
    }

    @Test
    @DisplayName("Test digest method")
    void testDigest() {
        SMB1SigningDigest digest = new SMB1SigningDigest(testMacSigningKey);
        byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        digest.update(data, 0, data.length);

        byte[] result = digest.digest();
        assertNotNull(result);

        } catch (final UnsupportedEncodingException e) {
            throw new ClIllegalStateException(e);
        }
        final byte[] digest = msgDigest.digest();

        final StringBuilder buffer = new StringBuilder(200);
        for (final byte element : digest) {
            final String tmp = Integer.toHexString(element & 0xff);
            if (tmp.length() == 1) {
                buffer.append('0').append(tmp);

client = TestClient(app)


def test_security_http_digest():
    response = client.get("/users/me", headers={"Authorization": "Digest foobar"})
    assert response.status_code == 200, response.text
    assert response.json() == {"scheme": "Digest", "credentials": "foobar"}


def test_security_http_digest_no_credentials():
    response = client.get("/users/me")

            Arrays.fill(sessionKey, (byte) 0xEE);

            Smb2SigningDigest digest = new Smb2SigningDigest(sessionKey, Smb2Constants.SMB2_DIALECT_0202, null);

            // Close multiple times should not throw
            digest.close();
            digest.close();
            digest.secureWipeKey();
            digest.close();

            // Operations should still fail
            byte[] data = new byte[128];

        // Given
        doNothing().when(messageBlock).setDigest(digest);
        when(messageBlock.getDigest()).thenReturn(digest);

        // When
        messageBlock.setDigest(digest);
        SMBSigningDigest retrievedDigest = messageBlock.getDigest();

        // Then
        assertEquals(digest, retrievedDigest);
        verify(messageBlock).setDigest(digest);
        verify(messageBlock).getDigest();
    }

    @Test

    protected byte[] engineDigest() {
        final byte[] digest = this.md5.digest();
        this.md5.update(this.opad);
        return this.md5.digest(digest);
    }

    @Override
    protected int engineDigest(final byte[] buf, final int offset, final int len) {
        final byte[] digest = this.md5.digest();
        this.md5.update(this.opad);
        this.md5.update(digest);
        try {

    protected byte[] engineDigest() {
        final byte[] digest = md5.digest();
        md5.update(opad);
        return md5.digest(digest);
    }

    @Override
    protected int engineDigest(final byte[] buf, final int offset, final int len) {
        final byte[] digest = md5.digest();
        md5.update(opad);
        md5.update(digest);
        try {
            return md5.digest(buf, offset, len);
        } catch (final Exception ex) {