return baos.toByteArray();
    }

    private byte[] calculateBindingHash(byte[] bindingInfo) throws IOException {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            return digest.digest(bindingInfo);
        } catch (NoSuchAlgorithmException e) {
            throw new IOException("SHA-256 not available", e);
        }
    }

    }

    /**
     * @param digest
     */
    public void setDigest(final SMBSigningDigest digest) {
        this.digest = digest;
    }

    /**
     * @return the digest
     */
    public SMBSigningDigest getDigest() {
        return this.digest;
    }

    /**
     * @return the context associated with this transport connection

 */
public interface SMBSigningDigest {

    /**
     * Performs MAC signing of the SMB. This is done as follows.
     * The signature field of the SMB is overwritten with the sequence number;
     * The MD5 digest of the MAC signing key + the entire SMB is taken;
     * The first 8 bytes of this are placed in the signature field.
     *
     * @param data
     *            The data.
     * @param offset

            assertTrue(testMessage.isResponse());
        }
    }

    @Nested
    @DisplayName("Digest Tests")
    class DigestTests {

        @Test
        @DisplayName("Should get and set digest")
        void testDigestProperty() {
            assertNull(testMessage.getDigest());
            testMessage.setDigest(mockDigest);

        dstIndex += writeHeaderWireFormat(dst, dstIndex);
        dstIndex += writeAndXWireFormat(dst, dstIndex);
        length = dstIndex - start;

        if (digest != null) {
            digest.sign(dst, headerStart, length, this, response);
        }

        return length;
    }

    /*
     * We overload this because we want readAndXWireFormat to

            public static final String DEFAULT_LANG = "default.lang";
            public static final String DEFAULT_CONTENT = "default.content";
            public static final String DEFAULT_DIGEST = "default.digest";
            // xapth.<field>=<value>
        }

        // config.*
        public static class Config {
            public static final String KEEP_ORIGINAL_BODY = "keep.original.body";

    }

    private AuthScheme getAuthScheme() {
        final String scheme = getProtocolScheme();
        if (Constants.BASIC.equals(scheme)) {
            return new BasicScheme();
        }
        if (Constants.DIGEST.equals(scheme)) {
            return new DigestScheme();
        }
        if (Constants.NTLM.equals(scheme)) {
            final Properties props = new Properties();

      },
      "timestamp": {
        "type": "date",
        "format": "date_optional_time"
      },
      "expires": {
        "type": "date",
        "format": "date_optional_time"
      },
      "digest": {
        "type": "text",
        "index": false
      },
      "doc_id": {
        "type": "keyword"
      },
      "favorite_count": {
        "type": "long"
      },
      "filename": {

        this.fid = fid;
        this.offset = offset;
        this.remaining = remaining;
        this.b = b;
        this.off = off;
        dataLength = len;
        digest = null; /* otherwise recycled commands
                        * like writeandx will choke if session
                        * closes in between */
    }

    @Override
    int getBatchLimit(final byte command) {

                    md4.update(responseKeyNT);
                    final byte[] userSessionKey = md4.digest();

                    final HMACT64 hmac = new HMACT64(userSessionKey);
                    hmac.update(sessionNonce);
                    final byte[] ntlm2SessionKey = hmac.digest();

                    if ((getFlags() & NTLMSSP_NEGOTIATE_KEY_EXCH) != 0) {
                        masterKey = new byte[16];