byte[] key7 = new byte[7];
        byte[] e8 = new byte[8];

        for( int i = 0; i < key.length / 7; i++ ) {
            System.arraycopy( key, i * 7, key7, 0, 7 );
            DES des = new DES( key7 );
            des.encrypt( data, e8 );
            System.arraycopy( e8, 0, e, i * 8, 8 );
        }
    }

    static String DEFAULT_DOMAIN;
    static String DEFAULT_USERNAME;
    static String DEFAULT_PASSWORD;

        byte[] result;
        result = cipher.doFinal(data);

        decrypt = new byte[result.length];
        System.arraycopy(result, 0, decrypt, 0, result.length);

        int tempSize = decrypt.length - 24;

        byte[] output = new byte[tempSize];
        System.arraycopy(decrypt, 24, output, 0, tempSize);

        decrypt = output;
        return decrypt;
    }

        int start = dstIndex;

        if (blob != null) {
            System.arraycopy(blob, 0, dst, dstIndex, blob.length );
            dstIndex += blob.length;
        } else {
            System.arraycopy( lmHash, 0, dst, dstIndex, lmHash.length );
            dstIndex += lmHash.length;
            System.arraycopy( ntHash, 0, dst, dstIndex, ntHash.length );
            dstIndex += ntHash.length;
    

            i--;
        }
        return n;
    }
    public void writeOctetArray(byte[] b, int i, int l) {
        System.arraycopy(b, i, buf, index, l);
        advance(l);
    }
    public void readOctetArray(byte[] b, int i, int l) {
        System.arraycopy(buf, index, b, i, l);
        advance(l);
    }


    public int getLength() {
        return deferred.length;
    }

                }
                foundEnd = true;
                break;
            }

            byte[] raw = new byte[avLen];
            System.arraycopy(data, pos, raw, 0, avLen);
            pairs.add(parseAvPair(avId, raw));

            pos += avLen;
        }
        if ( !foundEnd ) {
            throw new CIFSException("Missing AvEOL");
        }

            System.arraycopy( password, 0, dst, dstIndex, passwordLength );
            dstIndex += passwordLength;
        } else {
            // no password in tree connect
            dst[dstIndex++] = (byte)0x00;
        }
        dstIndex += writeString( path, dst, dstIndex );
        try {
            System.arraycopy( service.getBytes( "ASCII" ), 0, dst, dstIndex, service.length() );

        byte[] dk = deriveKeyAES(baseKey, cst); // Checksum key
        try {
            Mac m = Mac.getInstance("HmacSHA1");
            m.init(new SecretKeySpec(dk, HMAC_KEY));
            System.arraycopy(m.doFinal(input), 0, output, 0, 12);
            return output;
        }
        finally {
            Arrays.fill(dk, 0, dk.length, (byte) 0);
        }
    }

        int start = bufferIndex;

        if ( ( this.server.scapabilities & SmbConstants.CAP_EXTENDED_SECURITY ) == 0 ) {
            this.server.encryptionKey = new byte[this.server.encryptionKeyLength];
            System.arraycopy(buffer, bufferIndex, this.server.encryptionKey, 0, this.server.encryptionKeyLength);
            bufferIndex += this.server.encryptionKeyLength;
            if ( this.byteCount > this.server.encryptionKeyLength ) {

        Encdec.enc_uint32le(0x00000000, temp, 4); // Reserved
        Encdec.enc_uint64le(nanos1601, temp, 8);
        System.arraycopy(clientChallenge, 0, temp, 16, 8);
        Encdec.enc_uint32le(0x00000000, temp, 24); // Unknown
        if ( avPairs != null )
            System.arraycopy(avPairs, 0, temp, 28, avPairsLength);
        Encdec.enc_uint32le(0x00000000, temp, 28 + avPairsLength); // mystery bytes!

        bufferIndex += 4;
        this.messageLength = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        this.data = new byte[len - 16];
        if ( this.data.length > 0 ) {
            System.arraycopy(buffer, bufferIndex, this.data, 0, this.data.length);
        }
        return bufferIndex - start;
    }