1F106         ; disallowed_STD3_mapped ; 0035 002C     # 5.2  DIGIT FIVE COMMA
1F107         ; disallowed_STD3_mapped ; 0036 002C     # 5.2  DIGIT SIX COMMA
1F108         ; disallowed_STD3_mapped ; 0037 002C     # 5.2  DIGIT SEVEN COMMA
1F109         ; disallowed_STD3_mapped ; 0038 002C     # 5.2  DIGIT EIGHT COMMA
1F10A         ; disallowed_STD3_mapped ; 0039 002C     # 5.2  DIGIT NINE COMMA

        // 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);
    }

  patent or other intellectual property rights of any other entity.
  Each Contributor disclaims any liability to Recipient for claims
  brought by any other entity based on infringement of intellectual
  property rights or otherwise. As a condition to exercising the
  rights and licenses granted hereunder, each Recipient hereby
  assumes sole responsibility to secure any other intellectual
  property rights needed, if any. For example, if a third party

            return; /* CRITICAL */
        }
        digest.update(input, offset, len);
        updates++;
    }

    /**
     * Computes and returns the message digest.
     *
     * @return the computed digest bytes
     */
    public byte[] digest() {
        byte[] b = digest.digest();

        if (LogStream.level >= 5) {
            log.println("digest: ");
            Hexdump.hexdump(log, b, 0, b.length);

  }

  /** Hasher that updates a message digest. */
  private static final class MessageDigestHasher extends AbstractByteHasher {
    private final MessageDigest digest;
    private final int bytes;
    private boolean done;

    private MessageDigestHasher(MessageDigest digest, int bytes) {
      this.digest = digest;
      this.bytes = bytes;
    }

    @Override

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")

        SMBUtil.writeInt2(this.fid, dst, dstIndex);
        dstIndex += 2;
        if (this.digest != null) {
            SMB1SigningDigest.writeUTime(getConfig(), this.lastWriteTime, dst, dstIndex);
        } else {
            log.trace("SmbComClose without a digest");
        }
        return 6;
    }

    @Override
    protected int writeBytesWireFormat(final byte[] dst, final int dstIndex) {

            // Mock implementation
            return 0;
        }

        @Override
        public void setDigest(SMBSigningDigest digest) {
            this.digest = digest;
        }

        @Override
        public SMBSigningDigest getDigest() {
            return this.digest;
        }

        @Override
        public CommonServerMessageBlockResponse getResponse() {
            return this.response;

        } 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);

    try {
      MessageDigest digest = MessageDigest.getInstance(algorithmName);
      assertEquals(
          HashCode.fromBytes(digest.digest(input)), ALGORITHMS.get(algorithmName).hashBytes(input));
      for (int bytes = 4; bytes <= digest.getDigestLength(); bytes++) {
        assertEquals(
            HashCode.fromBytes(Arrays.copyOf(digest.digest(input), bytes)),