RTMPHandshake (Red5 :: Common server classes 1.0.9-RELEASE API)

java.lang.Object
- org.red5.server.net.rtmp.RTMPHandshake

All Implemented Interfaces:

IHandshake
```
public abstract class RTMPHandshake
extends Object
implements IHandshake
```
Generates and validates the RTMP handshake response for Flash Players. Client versions equal to or greater than Flash 9,0,124,0 require a nonzero value as the fifth byte of the handshake request.

Author:

Jacinto Shy II (jacinto.m.shy@ieee.org), Steven Zimmer (stevenlzimmer@gmail.com), Gavriloaie Eugen-Andrei, Ari-Pekka Viitanen, Paul Gregoire, Tiago Jacobs

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`algorithm`
`protected static byte[][]`	`BLOWFISH_KEYS` Blowfish keys for RTMPE (RTMP type 0x09) - 16 x 24
`protected org.apache.mina.core.buffer.IoBuffer`	`buffer`
`protected Cipher`	`cipherIn`
`protected Cipher`	`cipherOut`
`protected static BigInteger`	`DH_BASE`
`protected static BigInteger`	`DH_MODULUS`
`protected static byte[]`	`DH_MODULUS_BYTES` "Second Oakley Default Group" from RFC2409, section 6.2.
`protected static int`	`DIGEST_LENGTH`
`protected boolean`	`fp9Handshake`
`static byte[]`	`GENUINE_FMS_KEY`
`static byte[]`	`GENUINE_FP_KEY`
`static String[]`	`HANDSHAKE_TYPES`
`protected byte[]`	`handshakeBytes`
`protected byte`	`handshakeType`
`protected byte[]`	`incomingPublicKey`
`protected static int`	`KEY_LENGTH`
`protected KeyAgreement`	`keyAgreement`
`protected org.slf4j.Logger`	`log`
`protected byte[]`	`outgoingPublicKey`
`protected static Random`	`random`
`protected int`	`swfSize`
`protected byte[]`	`swfVerificationBytes`
`protected static int[][]`	`XTEA_KEYS` XTEA keys for RTMPE (RTMP type 0x08) - 16 x 4

Constructor Summary

Constructors
Constructor and Description

RTMPHandshake()

RTMPHandshake(byte handshakeType)

Constructors
Constructor and Description
`RTMPHandshake()`
`RTMPHandshake(byte handshakeType)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addBuffer(byte[] in)` Add a byte array to the buffer.
`void`	`addBuffer(org.apache.mina.core.buffer.IoBuffer in)` Add a IoBuffer to the buffer.
`void`	`calculateDigest(int digestPos, byte[] handshakeMessage, int handshakeOffset, byte[] key, int keyLen, byte[] digest, int digestOffset)` Calculates the digest given the its offset in the handshake data.
`void`	`calculateHMAC_SHA256(byte[] message, int messageOffset, int messageLen, byte[] key, int keyLen, byte[] digest, int digestOffset)` Calculates an HMAC SHA256 hash into the digest at the given offset.
`void`	`calculateSwfVerification(byte[] handshakeMessage, byte[] swfHash, int swfSize)` Calculates the swf verification token.
`protected abstract void`	`createHandshakeBytes()` Create the initial bytes for a request / response.
`protected KeyPair`	`generateKeyPair()` Creates a Diffie-Hellman key pair.
`static void`	`getBlowfishSignature(byte[] array, int offset, int keyid)` RTMPE type 9 uses Blowfish on the regular signature http://en.wikipedia.org/wiki/Blowfish_(cipher)
`byte[]`	`getBuffer()` Returns buffered byte array.
`org.apache.mina.core.buffer.IoBuffer`	`getBufferAsIoBuffer()` Returns buffered IoBuffer itself.
`int`	`getBufferSize()` Returns the buffer size.
`Cipher`	`getCipherIn()` Returns the contained handshake bytes.
`Cipher`	`getCipherOut()` Gets the DH offset in the handshake bytes array based on validation scheme Generates DH keypair Adds public key to handshake bytes
`int`	`getDHOffset(int algorithm, byte[] handshake, int bufferOffset)` Returns the DH offset from an array of bytes.
`protected int`	`getDHOffset1(byte[] handshake, int bufferOffset)` Returns the DH byte offset.
`protected int`	`getDHOffset2(byte[] handshake, int bufferOffset)` Returns the DH byte offset.
`int`	`getDigestOffset(int algorithm, byte[] handshake, int bufferOffset)` Returns the digest offset using current validation scheme.
`protected int`	`getDigestOffset1(byte[] handshake, int bufferOffset)` Returns a digest byte offset.
`protected int`	`getDigestOffset2(byte[] handshake, int bufferOffset)` Returns a digest byte offset.
`byte`	`getHandshakeType()` Returns the handshake type.
`protected byte[]`	`getPublicKey(KeyPair keyPair)` Returns the public key for a given key pair.
`protected byte[]`	`getSharedSecret(byte[] publicKeyBytes, KeyAgreement agreement)` Determines the validation scheme for given input.
`byte[]`	`getSwfVerificationBytes()` Returns the SWF verification bytes.
`static void`	`getXteaSignature(byte[] array, int offset, int keyid)` RTMPE type 8 uses XTEA on the regular signature http://en.wikipedia.org/wiki/XTEA
`protected void`	`initRC4Encryption(byte[] sharedSecret)` Prepare the ciphers.
`void`	`setHandshakeType(byte handshakeType)` Sets the handshake type.
`boolean`	`useEncryption()` Whether or not encryptions is in use.
`abstract boolean`	`validate(byte[] handshake)` Determines the validation scheme for given input.
`static boolean`	`validHandshakeType(byte handshakeType)` Returns whether or not a given handshake type is valid.
`boolean`	`verifyDigest(int digestPos, byte[] handshakeMessage, byte[] key, int keyLen)` Verifies the digest.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.red5.server.net.IHandshake
doHandshake

- Field Detail
  - log
```
protected org.slf4j.Logger log
```
  - HANDSHAKE_TYPES
```
public static final String[] HANDSHAKE_TYPES
```
  - GENUINE_FMS_KEY
```
public static final byte[] GENUINE_FMS_KEY
```
  - GENUINE_FP_KEY
```
public static final byte[] GENUINE_FP_KEY
```
  - DH_MODULUS_BYTES
```
protected static final byte[] DH_MODULUS_BYTES
```
    "Second Oakley Default Group" from RFC2409, section 6.2.
  - XTEA_KEYS
```
protected static final int[][] XTEA_KEYS
```
    XTEA keys for RTMPE (RTMP type 0x08) - 16 x 4
  - BLOWFISH_KEYS
```
protected static final byte[][] BLOWFISH_KEYS
```
    Blowfish keys for RTMPE (RTMP type 0x09) - 16 x 24
  - DH_MODULUS
```
protected static final BigInteger DH_MODULUS
```
  - DH_BASE
```
protected static final BigInteger DH_BASE
```
  - DIGEST_LENGTH
```
protected static final int DIGEST_LENGTH
```
    See Also:
    
    Constant Field Values
  - KEY_LENGTH
```
protected static final int KEY_LENGTH
```
    See Also:
    
    Constant Field Values
  - random
```
protected static final Random random
```
  - keyAgreement
```
protected KeyAgreement keyAgreement
```
  - cipherOut
```
protected Cipher cipherOut
```
  - cipherIn
```
protected Cipher cipherIn
```
  - handshakeType
```
protected byte handshakeType
```
  - handshakeBytes
```
protected byte[] handshakeBytes
```
  - incomingPublicKey
```
protected byte[] incomingPublicKey
```
  - outgoingPublicKey
```
protected byte[] outgoingPublicKey
```
  - swfSize
```
protected int swfSize
```
  - swfVerificationBytes
```
protected byte[] swfVerificationBytes
```
  - algorithm
```
protected int algorithm
```
  - fp9Handshake
```
protected boolean fp9Handshake
```
  - buffer
```
protected org.apache.mina.core.buffer.IoBuffer buffer
```
- Constructor Detail
  - RTMPHandshake
```
public RTMPHandshake()
```
  - RTMPHandshake
```
public RTMPHandshake(byte handshakeType)
```
- Method Detail
  - initRC4Encryption
```
protected void initRC4Encryption(byte[] sharedSecret)
```
    Prepare the ciphers.
    
    Parameters:
    
    sharedSecret - shared secret byte sequence
  - generateKeyPair
```
protected KeyPair generateKeyPair()
```
    Creates a Diffie-Hellman key pair.
    
    Returns:
    
    dh keypair
  - getPublicKey
```
protected byte[] getPublicKey(KeyPair keyPair)
```
    Returns the public key for a given key pair.
    
    Parameters:
    
    keyPair - key pair
    
    Returns:
    
    public key
  - getSharedSecret
```
protected byte[] getSharedSecret(byte[] publicKeyBytes,
                                 KeyAgreement agreement)
```
    Determines the validation scheme for given input.
    
    Parameters:
    
    publicKeyBytes - public key bytes
    
    agreement - key agreement
    
    Returns:
    
    shared secret bytes if client used a supported validation scheme
  - createHandshakeBytes
```
protected abstract void createHandshakeBytes()
```
    Create the initial bytes for a request / response.
  - validate
```
public abstract boolean validate(byte[] handshake)
```
    Determines the validation scheme for given input.
    
    Specified by:
    
    validate in interface IHandshake
    
    Parameters:
    
    handshake - handshake byte sequence
    
    Returns:
    
    true if its a supported validation scheme, false if unsupported
  - calculateDigest
```
public void calculateDigest(int digestPos,
                            byte[] handshakeMessage,
                            int handshakeOffset,
                            byte[] key,
                            int keyLen,
                            byte[] digest,
                            int digestOffset)
```
    Calculates the digest given the its offset in the handshake data.
    
    Parameters:
    
    digestPos - digest position
    
    handshakeMessage - handshake message
    
    handshakeOffset - handshake message offset
    
    key - contains the key
    
    keyLen - the length of the key
    
    digest - contains the calculated digest
    
    digestOffset - digest offset
  - verifyDigest
```
public boolean verifyDigest(int digestPos,
                            byte[] handshakeMessage,
                            byte[] key,
                            int keyLen)
```
    Verifies the digest.
    
    Parameters:
    
    digestPos - digest position
    
    handshakeMessage - handshake message
    
    key - contains the key
    
    keyLen - the length of the key
    
    Returns:
    
    true if valid and false otherwise
  - calculateHMAC_SHA256
```
public void calculateHMAC_SHA256(byte[] message,
                                 int messageOffset,
                                 int messageLen,
                                 byte[] key,
                                 int keyLen,
                                 byte[] digest,
                                 int digestOffset)
```
    Calculates an HMAC SHA256 hash into the digest at the given offset.
    
    Parameters:
    
    message - incoming bytes
    
    messageOffset - message offset
    
    messageLen - message length
    
    key - incoming key bytes
    
    keyLen - the length of the key
    
    digest - contains the calculated digest
    
    digestOffset - digest offset
  - calculateSwfVerification
```
public void calculateSwfVerification(byte[] handshakeMessage,
                                     byte[] swfHash,
                                     int swfSize)
```
    Calculates the swf verification token.
    
    Parameters:
    
    handshakeMessage - servers handshake bytes
    
    swfHash - hash of swf
    
    swfSize - size of swf
  - getDHOffset
```
public int getDHOffset(int algorithm,
                       byte[] handshake,
                       int bufferOffset)
```
    Returns the DH offset from an array of bytes.
    
    Parameters:
    
    algorithm - validation algorithm
    
    handshake - handshake sequence
    
    bufferOffset - buffer offset
    
    Returns:
    
    DH offset
  - getDHOffset1
```
protected int getDHOffset1(byte[] handshake,
                           int bufferOffset)
```
    Returns the DH byte offset.
    
    Parameters:
    
    handshake - handshake sequence
    
    bufferOffset - buffer offset
    
    Returns:
    
    dh offset
  - getDHOffset2
```
protected int getDHOffset2(byte[] handshake,
                           int bufferOffset)
```
    Returns the DH byte offset.
    
    Parameters:
    
    handshake - handshake sequence
    
    bufferOffset - buffer offset
    
    Returns:
    
    dh offset
  - getDigestOffset
```
public int getDigestOffset(int algorithm,
                           byte[] handshake,
                           int bufferOffset)
```
    Returns the digest offset using current validation scheme.
    
    Parameters:
    
    algorithm - validation algorithm
    
    handshake - handshake sequence
    
    bufferOffset - buffer offset
    
    Returns:
    
    digest offset
  - getDigestOffset1
```
protected int getDigestOffset1(byte[] handshake,
                               int bufferOffset)
```
    Returns a digest byte offset.
    
    Parameters:
    
    handshake - handshake sequence
    
    bufferOffset - buffer offset
    
    Returns:
    
    digest offset
  - getDigestOffset2
```
protected int getDigestOffset2(byte[] handshake,
                               int bufferOffset)
```
    Returns a digest byte offset.
    
    Parameters:
    
    handshake - handshake sequence
    
    bufferOffset - buffer offset
    
    Returns:
    
    digest offset
  - getXteaSignature
```
public static final void getXteaSignature(byte[] array,
                                          int offset,
                                          int keyid)
```
    RTMPE type 8 uses XTEA on the regular signature http://en.wikipedia.org/wiki/XTEA
    
    Parameters:
    
    array - array to get signature
    
    offset - offset to start from
    
    keyid - ID of XTEA key
  - getBlowfishSignature
```
public static final void getBlowfishSignature(byte[] array,
                                              int offset,
                                              int keyid)
```
    RTMPE type 9 uses Blowfish on the regular signature http://en.wikipedia.org/wiki/Blowfish_(cipher)
    
    Parameters:
    
    array - array to get signature
    
    offset - offset to start from
    
    keyid - ID of XTEA key
  - validHandshakeType
```
public static final boolean validHandshakeType(byte handshakeType)
```
    Returns whether or not a given handshake type is valid.
    
    Parameters:
    
    handshakeType - the type of handshake
    
    Returns:
    
    true if valid and supported, false otherwise
  - useEncryption
```
public boolean useEncryption()
```
    Whether or not encryptions is in use.
    
    Specified by:
    
    useEncryption in interface IHandshake
    
    Returns:
    
    true if handshake type is an encrypted type, false otherwise
  - setHandshakeType
```
public void setHandshakeType(byte handshakeType)
```
    Sets the handshake type. Currently only two types are supported, plain and encrypted.
    
    Parameters:
    
    handshakeType - handshake type
  - getHandshakeType
```
public byte getHandshakeType()
```
    Returns the handshake type.
    
    Returns:
    
    handshakeType
  - getCipherOut
```
public Cipher getCipherOut()
```
    Gets the DH offset in the handshake bytes array based on validation scheme Generates DH keypair Adds public key to handshake bytes
    
    Returns:
    
    cipher
  - getCipherIn
```
public Cipher getCipherIn()
```
    Returns the contained handshake bytes. These are just random bytes if the player is using an non-versioned player.
    
    Returns:
    
    cipher
  - getSwfVerificationBytes
```
public byte[] getSwfVerificationBytes()
```
    Returns the SWF verification bytes.
    
    Returns:
    
    swf verification bytes
  - getBufferSize
```
public int getBufferSize()
```
    Returns the buffer size.
    
    Returns:
    
    buffer remaining
  - addBuffer
```
public void addBuffer(byte[] in)
```
    Add a byte array to the buffer.
    
    Parameters:
    
    in - incoming bytes
  - addBuffer
```
public void addBuffer(org.apache.mina.core.buffer.IoBuffer in)
```
    Add a IoBuffer to the buffer.
    
    Parameters:
    
    in - incoming IoBuffer
  - getBufferAsIoBuffer
```
public org.apache.mina.core.buffer.IoBuffer getBufferAsIoBuffer()
```
    Returns buffered IoBuffer itself.
    
    Returns:
    
    IoBuffer
  - getBuffer
```
public byte[] getBuffer()
```
    Returns buffered byte array.
    
    Returns:
    
    bytes

Class RTMPHandshake

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.red5.server.net.IHandshake

Field Detail

log

HANDSHAKE_TYPES

GENUINE_FMS_KEY

GENUINE_FP_KEY

DH_MODULUS_BYTES

XTEA_KEYS

BLOWFISH_KEYS

DH_MODULUS

DH_BASE

DIGEST_LENGTH

KEY_LENGTH

random

keyAgreement

cipherOut

cipherIn

handshakeType

handshakeBytes

incomingPublicKey

outgoingPublicKey

swfSize

swfVerificationBytes

algorithm

fp9Handshake

buffer

Constructor Detail

RTMPHandshake

RTMPHandshake

Method Detail

initRC4Encryption

generateKeyPair

getPublicKey

getSharedSecret

createHandshakeBytes

validate

calculateDigest

verifyDigest

calculateHMAC_SHA256

calculateSwfVerification

getDHOffset

getDHOffset1

getDHOffset2

getDigestOffset

getDigestOffset1

getDigestOffset2

getXteaSignature

getBlowfishSignature

validHandshakeType

useEncryption

setHandshakeType

getHandshakeType

getCipherOut

getCipherIn

getSwfVerificationBytes

getBufferSize

addBuffer

addBuffer

getBufferAsIoBuffer

getBuffer