root/trunk/sources/thelib/src/protocols/rtmp/inboundrtmpprotocol.cpp

/*
 * Copyright (c) 2009, Gavriloaie Eugen-Andrei (shiretu@gmail.com)
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *              *Redistributions of source code must retain the above copyright notice,
 *               this list of conditions and the following disclaimer.
 *              *Redistributions in binary form must reproduce the above copyright
 *               notice, this list of conditions and the following disclaimer in the
 *               documentation and/or other materials provided with the distribution.
 *              *Neither the name of the DEVSS nor the names of its
 *               contributors may be used to endorse or promote products derived from
 *               this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "protocols/rtmp/inboundrtmpprotocol.h"
#include "buffering/iobuffer.h"
#include "protocols/rtmp/rtmpeprotocol.h"
#include "protocols/rtmp/basertmpappprotocolhandler.h"
#include "utils/crypto.h"

InboundRTMPProtocol::InboundRTMPProtocol()
: BaseRTMPProtocol(PT_INBOUNDRTMP) {
    _pKeyIn = NULL;
    _pKeyOut = NULL;
    _pOutputBuffer = NULL;
    _currentFPVersion = 0;
    _validationScheme = 0;
}

InboundRTMPProtocol::~InboundRTMPProtocol() {
    if (_pKeyIn != NULL) {
        delete _pKeyIn;
        _pKeyIn = NULL;
    }

    if (_pKeyOut != NULL) {
        delete _pKeyOut;
        _pKeyOut = NULL;
    }

    if (_pOutputBuffer != NULL) {
        delete[] _pOutputBuffer;
        _pOutputBuffer = NULL;
    }
}

bool InboundRTMPProtocol::PerformHandshake(IOBuffer &buffer) {
    switch (_rtmpState) {
        case RTMP_STATE_NOT_INITIALIZED:
        {
            if (GETAVAILABLEBYTESCOUNT(buffer) < 1537) {
                //FINEST("Not enough data");
                return true;
            }
            uint8_t handshakeType = GETIBPOINTER(buffer)[0];
            if (!buffer.Ignore(1)) {
                FATAL("Unable to ignore one byte");
                return false;
            }

            _currentFPVersion = ntohl(*((uint32_t *) (GETIBPOINTER(buffer) + 4))); //----MARKED-LONG---
            //FINEST("Flash player: %s", STR(_currentFlashPlayerVersion));

            switch (handshakeType) {
                case 3: //plain
                {
                    return PerformHandshake(buffer, false);
                }
                case 6: //encrypted
                {
                    return PerformHandshake(buffer, true);
                }
                default:
                {
                    FATAL("Handshake type not implemented: %d", handshakeType);
                    return false;
                }
            }
        }
        case RTMP_STATE_SERVER_RESPONSE_SENT:
        {
            //FINEST("I: Player request 2:\n%s", STR(*pInputBuffer));
            if (GETAVAILABLEBYTESCOUNT(buffer) < 1536) {
                return true;
            } else {
                //ignore the client's last handshake part
                if (!buffer.Ignore(1536)) {
                    FATAL("Unable to ignore inbound data");
                    return false;
                }
                _handshakeCompleted = true;
                _rtmpState = RTMP_STATE_DONE;

                if (_pKeyIn != NULL && _pKeyOut != NULL) {
                    //insert the RTMPE protocol in the current protocol stack
                    BaseProtocol *pFarProtocol = GetFarProtocol();
                    RTMPEProtocol *pRTMPE = new RTMPEProtocol(_pKeyIn, _pKeyOut);
                    ResetFarProtocol();
                    pFarProtocol->SetNearProtocol(pRTMPE);
                    pRTMPE->SetNearProtocol(this);
                    FINEST("New protocol chain: %s", STR(*pFarProtocol));

                    //decrypt the leftovers
                    RC4(_pKeyIn, GETAVAILABLEBYTESCOUNT(buffer),
                            GETIBPOINTER(buffer),
                            GETIBPOINTER(buffer));
                }

                return true;
            }
        }
        default:
        {
            FATAL("Invalid RTMP state: %d", _rtmpState);
            return false;
        }
    }
}

bool InboundRTMPProtocol::ValidateClient(IOBuffer &inputBuffer) {
    if (_currentFPVersion == 0) {
        WARN("This version of player doesn't support validation");
        return true;
    }
    if (ValidateClientScheme(inputBuffer, 0)) {
        _validationScheme = 0;
        return true;
    }
    if (ValidateClientScheme(inputBuffer, 1)) {
        _validationScheme = 1;
        return true;
    }
    FATAL("Unable to validate client");
    return false;
}

bool InboundRTMPProtocol::ValidateClientScheme(IOBuffer &inputBuffer, uint8_t scheme) {
    uint8_t *pBuffer = GETIBPOINTER(inputBuffer);

    uint32_t clientDigestOffset = GetDigestOffset(pBuffer, scheme);

    uint8_t *pTempBuffer = new uint8_t[1536 - 32];
    memcpy(pTempBuffer, pBuffer, clientDigestOffset);
    memcpy(pTempBuffer + clientDigestOffset, pBuffer + clientDigestOffset + 32,
            1536 - clientDigestOffset - 32);

    //uint8_t *pTempHash = new uint8_t[mhash_get_hash_pblock(MHASH_SHA256)];
    uint8_t *pTempHash = new uint8_t[512];
    HMACsha256(pTempBuffer, 1536 - 32, genuineFPKey, 30, pTempHash);

    bool result = true;
    for (uint32_t i = 0; i < 32; i++) {
        if (pBuffer[clientDigestOffset + i] != pTempHash[i]) {
            result = false;
            break;
        }
    }

    delete[] pTempBuffer;
    delete[] pTempHash;

    return result;
}

bool InboundRTMPProtocol::PerformHandshake(IOBuffer &buffer, bool encrypted) {
    if (encrypted || _pProtocolHandler->ValidateHandshake()) {
        if (!ValidateClient(buffer)) {
            FATAL("Unable to validate client");
            return false;
        }
    }

    //get the buffers
    uint8_t *pInputBuffer = GETIBPOINTER(buffer);
    if (_pOutputBuffer == NULL) {
        _pOutputBuffer = new uint8_t[3072];
    } else {
        delete[] _pOutputBuffer;
        _pOutputBuffer = new uint8_t[3072];
    }

    //timestamp
    *(uint32_t *) _pOutputBuffer = 0;

    //version
    *(uint32_t *) (_pOutputBuffer + 4) = htonl(0x01020304); //----MARKED-LONG---

    //generate random data
    srand((uint32_t) time(NULL));
    for (uint32_t i = 8; i < 3072; i++) {
        _pOutputBuffer[i] = rand() % 256;
    }

    //**** FIRST 1536 bytes from server response ****//
    //compute DH key position
    uint32_t serverDHOffset = GetDHOffset(_pOutputBuffer, _validationScheme);
    uint32_t clientDHOffset = GetDHOffset(pInputBuffer, _validationScheme);
    //FINEST("serverDHOffset: %u", serverDHOffset);

    //generate DH key
    DHWrapper dhWrapper(1024);

    if (!dhWrapper.Initialize()) {
        FATAL("Unable to initialize DH wrapper");
        return false;
    }

    if (!dhWrapper.CreateSharedKey(pInputBuffer + clientDHOffset, 128)) {
        FATAL("Unable to create shared key");
        return false;
    }

    if (!dhWrapper.CopyPublicKey(_pOutputBuffer + serverDHOffset, 128)) {
        FATAL("Couldn't write public key!");
        return false;
    }

    if (encrypted) {
        uint8_t secretKey[128];
        if (!dhWrapper.CopySharedKey(secretKey, sizeof (secretKey))) {
            FATAL("Unable to copy shared key");
            return false;
        }

        _pKeyIn = new RC4_KEY;
        _pKeyOut = new RC4_KEY;
        InitRC4Encryption(
                secretKey,
                (uint8_t*) & pInputBuffer[clientDHOffset],
                (uint8_t*) & _pOutputBuffer[serverDHOffset],
                _pKeyIn,
                _pKeyOut);

        //bring the keys to correct cursor
        uint8_t data[1536];
        RC4(_pKeyIn, 1536, data, data);
        RC4(_pKeyOut, 1536, data, data);
    }

    //generate the digest
    uint32_t serverDigestOffset = GetDigestOffset(_pOutputBuffer, _validationScheme);
    //FINEST("serverDigestOffset: %u", serverDigestOffset);

    uint8_t *pTempBuffer = new uint8_t[1536 - 32];
    memcpy(pTempBuffer, _pOutputBuffer, serverDigestOffset);
    memcpy(pTempBuffer + serverDigestOffset, _pOutputBuffer + serverDigestOffset + 32,
            1536 - serverDigestOffset - 32);

    uint8_t *pTempHash = new uint8_t[512];
    HMACsha256(pTempBuffer, 1536 - 32, genuineFMSKey, 36, pTempHash);

    //put the digest in place
    memcpy(_pOutputBuffer + serverDigestOffset, pTempHash, 32);

    //cleanup
    delete[] pTempBuffer;
    delete[] pTempHash;


    //**** SECOND 1536 bytes from server response ****//
    //Compute the chalange index from the initial client request
    uint32_t keyChallengeIndex = GetDigestOffset(pInputBuffer, _validationScheme);
    //FINEST("keyChallengeIndex: %u", keyChallengeIndex);

    //compute the key
    pTempHash = new uint8_t[512];
    HMACsha256(pInputBuffer + keyChallengeIndex, //pData
            32, //dataLength
            BaseRTMPProtocol::genuineFMSKey, //key
            68, //keyLength
            pTempHash //pResult
            );

    //generate the hash
    uint8_t *pLastHash = new uint8_t[512];
    HMACsha256(_pOutputBuffer + 1536, //pData
            1536 - 32, //dataLength
            pTempHash, //key
            32, //keyLength
            pLastHash //pResult
            );

    //put the hash where it belongs
    memcpy(_pOutputBuffer + 1536 * 2 - 32, pLastHash, 32);


    //cleanup
    delete[] pTempHash;
    delete[] pLastHash;
    //***** DONE BUILDING THE RESPONSE ***//


    //wire the response
    if (encrypted)
        _outputBuffer.PutByte(6);
    else
        _outputBuffer.PutByte(3);
    _outputBuffer.PutBuffer(_pOutputBuffer, 3072);

    //final cleanup
    delete[] _pOutputBuffer;
    _pOutputBuffer = NULL;
    if (!buffer.IgnoreAll()) {
        FATAL("Unable to ignore input buffer");
        return false;
    }

    //signal outbound data
    if (!_pFarProtocol->EnqueueForOutbound()) {
        FATAL("Unable to signal outbound data");
        return false;
    }

    //move to the next stage in the handshake
    _rtmpState = RTMP_STATE_SERVER_RESPONSE_SENT;

    return true;
}