Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.bouncycastle.crypto.tls;
  
A generic TLS MAC implementation, acting as an HMAC based on some underlying Digest.
 
 public class TlsMac
 {
     protected TlsContext context;
     protected byte[] secret;
     protected Mac mac;
     protected int digestBlockSize;
     protected int digestOverhead;
     protected int macLength;

    
Generate a new instance of an TlsMac.

Parameters:
context the TLS client context
digest The digest to use.
key A byte-array where the key for this MAC is located.
keyOff The number of bytes to skip, before the key starts in the buffer.
keyLen The length of the key.
 
     public TlsMac(TlsContext contextDigest digestbyte[] keyint keyOffint keyLen)
     {
         this. = context;
 
         KeyParameter keyParameter = new KeyParameter(keykeyOffkeyLen);
 
         this. = Arrays.clone(keyParameter.getKey());
 
         // TODO This should check the actual algorithm, not rely on the engine type
         if (digest instanceof LongDigest)
         {
             this. = 128;
             this. = 16;
         }
         else
         {
             this. = 64;
             this. = 8;
         }
 
         if (TlsUtils.isSSL(context))
         {
             this. = new SSL3Mac(digest);
 
             // TODO This should check the actual algorithm, not assume based on the digest size
             if (digest.getDigestSize() == 20)
             {
                 /*
                  * NOTE: When SHA-1 is used with the SSL 3.0 MAC, the secret + input pad is not
                  * digest block-aligned.
                  */
                 this. = 4;
             }
         }
         else
         {
             this. = new HMac(digest);
 
             // NOTE: The input pad for HMAC is always a full digest block
         }
 
         this..init(keyParameter);
 
         this. = .getMacSize();
         if (context.getSecurityParameters().)
         {
             this. = Math.min(this., 10);
         }
     }

    

Returns:
the MAC write secret
 
     public byte[] getMACSecret()
     {
         return this.;
     }

    

Returns:
The output length of this MAC.
 
     public int getSize()
     {
         return ;
     }

    
Calculate the MAC for some given data.

Parameters:
type The message type of the message.
message A byte-buffer containing the message.
offset The number of bytes to skip, before the message starts.
length The length of the message.
Returns:
A new byte-buffer containing the MAC value.
    public byte[] calculateMac(long seqNoshort typebyte[] messageint offsetint length)
    {
        ProtocolVersion serverVersion = .getServerVersion();
        boolean isSSL = serverVersion.isSSL();
        byte[] macHeader = new byte[isSSL ? 11 : 13];
        TlsUtils.writeUint64(seqNomacHeader, 0);
        TlsUtils.writeUint8(typemacHeader, 8);
        if (!isSSL)
        {
            TlsUtils.writeVersion(serverVersionmacHeader, 9);
        }
        TlsUtils.writeUint16(lengthmacHeadermacHeader.length - 2);
        .update(macHeader, 0, macHeader.length);
        .update(messageoffsetlength);
        byte[] result = new byte[.getMacSize()];
        .doFinal(result, 0);
        return truncate(result);
    }
    public byte[] calculateMacConstantTime(long seqNoshort typebyte[] messageint offsetint length,
        int fullLengthbyte[] dummyData)
    {
        /*
         * Actual MAC only calculated on 'length' bytes...
         */
        byte[] result = calculateMac(seqNotypemessageoffsetlength);
        /*
         * ...but ensure a constant number of complete digest blocks are processed (as many as would
         * be needed for 'fullLength' bytes of input).
         */
        int headerLength = TlsUtils.isSSL() ? 11 : 13;
        // How many extra full blocks do we need to calculate?
        int extra = getDigestBlockCount(headerLength + fullLength) - getDigestBlockCount(headerLength + length);
        while (--extra >= 0)
        {
            .update(dummyData, 0, );
        }
        // One more byte in case the implementation is "lazy" about processing blocks
        .update(dummyData[0]);
        .reset();
        return result;
    }
    protected int getDigestBlockCount(int inputLength)
    {
        // NOTE: This calculation assumes a minimum of 1 pad byte
        return (inputLength + ) / ;
    }
    protected byte[] truncate(byte[] bs)
    {
        if (bs.length <= )
        {
            return bs;
        }
        return Arrays.copyOf(bs);
    }
New to GrepCode? Check out our FAQ X