How to avoid down cast here

class RawDataBase {
private:    
    std::string data;
}
class RawDataA : public RawDataBase {
private:    
    int spec_data_for_a1;
    int spec_data_for_a2;
} 
class RawDataB : public RawDataBase {
private:    
    int spec_data__for_b;
}

class MessageBase {
private:    
    int x;
    int y;
    int z;
public:
    virtual void Decode(RawDataBase *raw){
        // extract x,y,z from raw.data
    }

}


class MessageA : public MessageBase {
private:    
    int spec_data_for_a1;
    int spec_data_for_a2;
public:
    /* Here raw must be RawDataA*/
    virtual void Decode(RawDataBase *raw) {
        MessageBase::Decode(raw);
        RawDataA raw_data = static_cast<RawDataA*>(raw);
        // extract spec_data_for_a1, spec_data_for_a2 from raw_data

    }
} 
class MessageB : public MessageBase {
private:    
    int spec_data__for_b;
public:
    /* Here raw must be RawDataB*/
    virtual void Decode(RawDataBase *raw) {
        MessageBase::Decode(raw);
        RawDataB raw_data = static_cast<RawDataB*>(raw);
        // extract spec_data__for_b from raw_data       
    }
} 

Hi experts, I have a design issue while decoding RawData to Message. There are two types of RawData (RawDataA & RawDataB), RawDataA will be decoded as MessageA, RawDataB will be decoded as MessageB. Both of RawDataA and RawDataB shared some common binary (data). So RawDataBase was created, RawDataA and RawDataB are derived from RawDataBase. For same reason, MessageA and MessageB are derived from MessageBase. Then, one virtual Decode function is added into MessageBase, it takes RawDataBase as its parameters. But there is some problem in MessageA and MessageB. For MessageA, the parameters actually should always be RawDataA, then, a down cast has been done here. But someone says there must be some design issue when a down cast has to been used in code. So My question is how to design the code for this issue. Thanks!