// Test encoding/decoding
        byte[] encoded = nic.encode();
        assertNotNull(encoded);
        assertEquals(Smb2ChannelCapabilities.NETWORK_INTERFACE_INFO_SIZE, encoded.length);

        NetworkInterfaceInfo decoded = NetworkInterfaceInfo.decode(encoded, 0);
        assertEquals(nic.getInterfaceIndex(), decoded.getInterfaceIndex());

  )
  fun keyPair(): KeyPair = keyPair

  /**
   * Returns the certificate encoded in [PEM format][rfc_7468].
   *
   * [rfc_7468]: https://tools.ietf.org/html/rfc7468
   */
  fun certificatePem(): String = certificate.certificatePem()

  /**
   * Returns the private key encoded in [PKCS #8][rfc_5208] [PEM format][rfc_7468].
   *
   * [rfc_5208]: https://tools.ietf.org/html/rfc5208

            shift += 7
          } else {
            result += b shl shift // Last byte.
            break
          }
        }
        return result
      }

      /** Reads a potentially Huffman encoded byte string. */
      @Throws(IOException::class)
      fun readByteString(): ByteString {
        val firstByte = readByte()
        val huffmanDecode = firstByte and 0x80 == 0x80 // 1NNNNNNN

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.smb;

import org.bouncycastle.util.encoders.Hex;

/**
 * Authenticator directly specifing the user's NT hash
 *
 * @author mbechler
 *
 */
public class NtlmNtHashAuthenticator extends NtlmPasswordAuthenticator {

            this.securityProvider.unwrap(fbuf);
        }
    }

    /**
     * Encode a DCE/RPC message for transmission
     *
     * @param msg
     *            the message to encode
     * @param out
     *            the output buffer for the encoded message
     * @return the NdrBuffer containing the encoded message
     * @throws NdrException
     *            if there is an error encoding the message

    /**
     * Create SMB Direct Negotiate Request
     */
    public SmbDirectNegotiateRequest() {
    }

    /**
     * Encode to byte array
     *
     * @return encoded message
     */
    public byte[] encode() {
        byte[] data = new byte[32];

        int idx = 0;
        SMBUtil.writeInt2(minVersion, data, idx);
        idx += 2;

   * non-optional member but be included in sequence.
   *
   * TODO: for sets, sort by tag when encoding.
   * TODO: for set ofs, sort by encoded value when encoding.
   */
  fun <T> sequence(
    name: String,
    vararg members: DerAdapter<*>,
    decompose: (T) -> List<*>,
    construct: (List<*>) -> T,
  ): BasicDerAdapter<T> {
    val codec =

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

    /**
     * Encodes this SPNEGO token to a byte array
     * @return the encoded token bytes
     */
    public abstract byte[] toByteArray();

    /**
     * Parses the provided token bytes to populate this SPNEGO token
     * @param token the token bytes to parse

		switch v := dbValue.(type) {
		case []byte:
			bytesValue = v
		default:
			return fmt.Errorf("failed to unmarshal gob value: %#v", dbValue)
		}
		if len(bytesValue) > 0 {
			decoder := gob.NewDecoder(bytes.NewBuffer(bytesValue))
			err = decoder.Decode(fieldValue.Interface())
		}
	}
	field.ReflectValueOf(ctx, dst).Set(fieldValue.Elem())
	return
}

// Value implements serializer interface

     */
    int decode(byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException;

    /**
     * Encodes this message into a byte array.
     *
     * @param dst the destination byte array
     * @param dstIndex the starting index in the destination array
     * @return message length
     */
    int encode(byte[] dst, int dstIndex);

    /**
     * Sets the signing digest for this message.
     *