* most once unless the underlying {@code get()} throws an exception. The supplier's serialized
   * form does not contain the cached value, which will be recalculated when {@code get()} is called
   * on the deserialized instance.
   *
   * <p>When the underlying delegate throws an exception then this memoizing supplier will keep
   * delegating calls until it returns valid data.

   * most once unless the underlying {@code get()} throws an exception. The supplier's serialized
   * form does not contain the cached value, which will be recalculated when {@code get()} is called
   * on the deserialized instance.
   *
   * <p>When the underlying delegate throws an exception then this memoizing supplier will keep
   * delegating calls until it returns valid data.

     * @param clientChallenge the client challenge bytes
     * @param nanos1601 the timestamp in nanoseconds since 1601
     * @param avPairs the AV pairs from the Type 2 message
     * @return the calculated response
     */
    public static byte[] getNTLMv2Response(final byte[] responseKeyNT, final byte[] serverChallenge, final byte[] clientChallenge,
            final long nanos1601, final byte[] avPairs) {

     *
     * @param keyusage the Kerberos key usage number for this operation
     * @param key the encryption key to use for MAC calculation
     * @param data the data to calculate the MAC for
     * @return the calculated MAC bytes
     * @throws GeneralSecurityException if cryptographic operations fail
     */
    public static byte[] calculateMacArcfourHMACMD5(int keyusage, Key key, byte[] data) throws GeneralSecurityException {

						for idx, sh := range parityData {
							calculated := splitData[idx]
							if !bytes.Equal(calculated, sh) {
								off := 0
								for i, v := range sh {
									if v != calculated[i] {
										off = i
										break
									}
								}
								calculated := calculated[off:]
								inFile := sh[off:]
								extra := ""
								if len(calculated) != len(inFile) {

            return; /* CRITICAL */
        }
        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: ");

     */
    public void setMic(final byte[] mic) {
        this.mic = mic;
    }

    /**
     * Checks whether a message integrity code (MIC) should be calculated for this message.
     *
     * @return whether a MIC should be calculated
     */
    public boolean isMICRequired() {
        return this.micRequired;
    }

    @Override
    public byte[] toByteArray() throws IOException {

   * Returns the current sum. The returned value is NOT an atomic snapshot; invocation in
   * the absence of concurrent updates returns an accurate result, but concurrent updates that occur
   * while the sum is being calculated might not be incorporated.
   *
   * @return the sum
   */
  @Override
  public long sum() {
    long sum = base;
    Cell[] as = cells;
    if (as != null) {
      int n = as.length;

        // Using test vector from RFC 2104 adapted for HMACT64
        byte[] key = new byte[16];
        Arrays.fill(key, (byte) 0x0b);
        byte[] data = "Hi There".getBytes();

        // Expected result calculated manually for HMACT64 with this key and data
        HMACT64 hmac = new HMACT64(key);
        hmac.engineUpdate(data, 0, data.length);
        byte[] result = hmac.engineDigest();

        }
    }

    @Test
    @DisplayName("Test maxOutputResponse calculation with transaction buffer size")
    void testMaxOutputResponseCalculation() {
        // Test that maxOutputResponse is properly calculated from transaction buffer size
        when(mockConfig.getTransactionBufferSize()).thenReturn(8192);

        Smb2IoctlRequest request = new Smb2IoctlRequest(mockConfig, TEST_CONTROL_CODE);