/**
     * Get an MD4 message digest instance.
     * @return MD4 digest instance
     */
    public static MessageDigest getMD4() {
        try {
            return MessageDigest.getInstance("MD4", getProvider());
        } catch (final NoSuchAlgorithmException e) {
            throw new CIFSUnsupportedCryptoException(e);
        }
    }

    /**
     * Get an MD5 message digest instance.
     * @return MD5 digest instance

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

                        }

                        uid = response.uid;

                        if (request.digest != null) {
                            /* success - install the signing digest */
                            transport.digest = request.digest;
                        }

                        connectionState = 2;

                        state = 0;

     */
    int encode(byte[] dst, int dstIndex);

    /**
     * Sets the signing digest for this message.
     *
     * @param digest the signing digest to set
     */
    void setDigest(SMBSigningDigest digest);

    /**
     * Gets the signing digest for this message.
     *
     * @return the signing digest
     */
    SMBSigningDigest getDigest();

    /**

        assertEquals(expectedEncodeLength, response.encode(dst, dstIndex));

        // Test digest methods
        doNothing().when(response).setDigest(digest);
        when(response.getDigest()).thenReturn(digest);
        response.setDigest(digest);
        assertEquals(digest, response.getDigest());

        // Test mid methods
        long mid = 123456L;

                final HMACT64 userKey = new HMACT64(ntlmv2Hash);
                userKey.update(hmac.digest());
                userKey.digest(dest, offset, 16);
                break;
            default:
                md4.update(md4.digest());
                md4.digest(dest, offset, 16);
                break;
            }
        } catch (final Exception e) {
            throw new SmbException("", e);

errors.invalid_query_parse_error = La requête donnée n'est pas valide.
errors.invalid_query_sort_value = Le tri spécifié {0} n'est pas valide.
errors.invalid_query_unsupported_sort_field = Le tri spécifié {0} n'est pas pris en charge.
errors.invalid_query_unsupported_sort_order = L'ordre de tri spécifié {0} n'est pas pris en charge.
errors.invalid_query_cannot_process=Impossible de traiter la requête spécifiée.

            return 0;
        }

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

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

        @Override
        public void setResponse(CommonServerMessageBlockResponse msg) {

            }

            // SMB 3.1.1 spec: Hash = Hash(PreviousHash || Message)
            digest.update(previousHash);
            digest.update(messageData);

            return digest.digest();
        } catch (NoSuchAlgorithmException e) {
            throw new CIFSException("Hash algorithm not available: " + hashAlgorithm, e);
        }
    }

    /**
     * Gets the name of a hash algorithm.
     *

 * [OkHttp AWS Signer](https://github.com/babbel/okhttp-aws-signer): AWS V4 signing algorithm for OkHttp requests
 * [okhttp-digest](https://github.com/rburgst/okhttp-digest): A digest authenticator for OkHttp.
 * [OkHttp Idling Resource](https://github.com/JakeWharton/okhttp-idling-resource): An Espresso IdlingResource for OkHttp.