import sun.security.krb5.Confounder; //导入依赖的package包/类
public synchronized void randInit() {
    /*
     * Sequence numbers fall in the range 0 through 2^32 - 1 and wrap
     * to zero following the value 2^32 - 1.
     * Previous implementations used signed sequence numbers.
     * Workaround implementation incompatibilities by not generating
     * initial sequence numbers greater than 2^30, as done
     * in MIT distribution.
     */
    // get the random confounder
    byte[] data = Confounder.bytes(4);
    data[0] = (byte)(data[0] & 0x3f);
    int result = ((data[3] & 0xff) |
                    ((data[2] & 0xff) << 8) |
                    ((data[1] & 0xff) << 16) |
                    ((data[0] & 0xff) << 24));
    if (result == 0) {
       result = 1;
    }
    lastSeqNumber = result;
}
 

import sun.security.krb5.Confounder; //导入依赖的package包/类
public WrapToken(Krb5Context context, MessageProp prop,
                 byte[] dataBytes, int dataOffset, int dataLen)
    throws GSSException {

    super(Krb5Token.WRAP_ID, context);

    confounder = Confounder.bytes(CONFOUNDER_SIZE);

    padding = getPadding(dataLen);
    dataSize = confounder.length + dataLen + padding.length;
    this.dataBytes = dataBytes;
    this.dataOffset = dataOffset;
    this.dataLen = dataLen;

    /*
      debug("\nWrapToken cons: data to wrap is [" +
      getHexBytes(confounder) + " " +
      getHexBytes(dataBytes, dataOffset, dataLen) + " " +
      // padding is never null for Wrap
      getHexBytes(padding) + "]\n");
     */

    genSignAndSeqNumber(prop,
                        confounder,
                        dataBytes, dataOffset, dataLen,
                        padding);

    /*
     * If the application decides to ask for privacy when the context
     * did not negotiate for it, do not provide it. The peer might not
     * have support for it. The app will realize this with a call to
     * pop.getPrivacy() after wrap().
     */
    if (!context.getConfState())
        prop.setPrivacy(false);

    privacy = prop.getPrivacy();
}
 

import sun.security.krb5.Confounder; //导入依赖的package包/类
/**
 * Calculates keyed checksum.
 * @param data the data used to generate the checksum.
 * @param size length of the data.
 * @param key the key used to encrypt the checksum.
 * @return keyed checksum.
 *
 * @modified by Yanni Zhang, 12/08/99.
 */
public byte[] calculateKeyedChecksum(byte[] data, int size, byte[] key,
    int usage) throws KrbCryptoException {
    //prepend confounder
    byte[] new_data = new byte[size + confounderSize()];
    byte[] conf = Confounder.bytes(confounderSize());
    System.arraycopy(conf, 0, new_data, 0, confounderSize());
    System.arraycopy(data, 0, new_data, confounderSize(), size);

    //calculate md5 cksum
    byte[] mdc_cksum = calculateChecksum(new_data, new_data.length);
    byte[] cksum = new byte[cksumSize()];
    System.arraycopy(conf, 0, cksum, 0, confounderSize());
    System.arraycopy(mdc_cksum, 0, cksum, confounderSize(),
                     cksumSize() - confounderSize());

    //compute modified key
    byte[] new_key = new byte[keySize()];
    System.arraycopy(key, 0, new_key, 0, key.length);
    for (int i = 0; i < new_key.length; i++)
    new_key[i] = (byte)(new_key[i] ^ 0xf0);
    //check for weak keys
    try {
        if (DESKeySpec.isWeak(new_key, 0)) {
            new_key[7] = (byte)(new_key[7] ^ 0xF0);
        }
    } catch (InvalidKeyException ex) {
        // swallow, since it should never happen
    }
    byte[] ivec = new byte[new_key.length];

    //des-cbc encrypt
    byte[] enc_cksum = new byte[cksum.length];
    Des.cbc_encrypt(cksum, enc_cksum, new_key, ivec, true);
    return enc_cksum;
}
 

import sun.security.krb5.Confounder; //导入依赖的package包/类
/**
 * Writes a WrapToken_v2 object
 */
public WrapToken_v2(Krb5Context context, MessageProp prop,
                 byte[] dataBytes, int dataOffset, int dataLen)
        throws GSSException {

    super(Krb5Token.WRAP_ID_v2, context);

    confounder = Confounder.bytes(CONFOUNDER_SIZE);

    // debug("\nWrapToken cons: data to wrap is [" +
    // getHexBytes(confounder) + " " +
    // getHexBytes(dataBytes, dataOffset, dataLen) + "]\n");

    genSignAndSeqNumber(prop, dataBytes, dataOffset, dataLen);

    /*
     * If the application decides to ask for privacy when the context
     * did not negotiate for it, do not provide it. The peer might not
     * have support for it. The app will realize this with a call to
     * pop.getPrivacy() after wrap().
     */
    if (!context.getConfState())
        prop.setPrivacy(false);

    privacy = prop.getPrivacy();

    if (!privacy) {
        // Wrap Tokens (without confidentiality) =
        // { 16 byte token_header | plaintext | 12-byte HMAC }
        // where HMAC is on { plaintext | token_header }

        tokenData = new byte[dataLen + checksum.length];
        System.arraycopy(dataBytes, dataOffset, tokenData, 0, dataLen);
        System.arraycopy(checksum, 0, tokenData, dataLen, checksum.length);
    } else {
        // Wrap Tokens (with confidentiality) =
        // { 16 byte token_header |
        // Encrypt(16-byte confounder | plaintext | token_header) |
        // 12-byte HMAC }

        tokenData = cipherHelper.encryptData(this, confounder, getTokenHeader(),
            dataBytes, dataOffset, dataLen, getKeyUsage());
    }
}