pcodeinject.hh

Go to the documentation of this file.

/* ###
 * IP: GHIDRA
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef __PCODEINJECT__
#define __PCODEINJECT__
 
#include "emulateutil.hh"
 
class Architecture;
 
class InjectParameter {
  friend class InjectPayload;
  string name;      
  int4 index;       
  uint4 size;       
public:
  InjectParameter(const string &nm,uint4 sz) :name(nm) { index = 0; size = sz; }    
  const string &getName(void) const { return name; }    
  int4 getIndex(void) const { return index; }       
  uint4 getSize(void) const { return size; }        
};
 
class InjectContext {
public:
  Architecture *glb;            
  Address baseaddr;         
  Address nextaddr;         
  Address calladdr;         
  vector<VarnodeData> inputlist;    
  vector<VarnodeData> output;       
  virtual ~InjectContext(void) {}   
  virtual void clear(void) { inputlist.clear(); output.clear(); }   
 
  virtual void saveXml(ostream &s) const=0;
};
 
class InjectPayload {
public:
  enum {
    CALLFIXUP_TYPE = 1,     
    CALLOTHERFIXUP_TYPE = 2,    
    CALLMECHANISM_TYPE = 3, 
    EXECUTABLEPCODE_TYPE = 4    
  };
protected:
  string name;          
  int4 type;            
  bool dynamic;         
  bool incidentalCopy;      
  int4 paramshift;      
  vector<InjectParameter> inputlist;        
  vector<InjectParameter> output;       
  static void readParameter(const Element *el,string &name,uint4 &size);
  void orderParameters(void);           
public:
  InjectPayload(const string &nm,int4 tp) { name=nm; type=tp; paramshift=0; dynamic = false; incidentalCopy = false; }  
  int4 getParamShift(void) const { return paramshift; } 
  bool isDynamic(void) const { return dynamic; }    
  bool isIncidentalCopy(void) const { return incidentalCopy; }  
  int4 sizeInput(void) const { return inputlist.size(); }   
  int4 sizeOutput(void) const { return output.size(); }     
  InjectParameter &getInput(int4 i) { return inputlist[i]; }    
  InjectParameter &getOutput(int4 i) { return output[i]; }  
  virtual ~InjectPayload(void) {}               
 
  virtual void inject(InjectContext &context,PcodeEmit &emit) const=0;
 
  virtual void restoreXml(const Element *el);       
  virtual void printTemplate(ostream &s) const=0;   
  string getName(void) const { return name; }       
  int4 getType(void) const { return type; }     
  virtual string getSource(void) const=0;       
};
 
class ExecutablePcode : public InjectPayload {
  Architecture *glb;            
  string source;            
  bool built;               
  EmulateSnippet emulator;      
  vector<uintb> inputList;      
  vector<uintb> outputList;     
  PcodeEmit *emitter;           
  void build(void);         
public:
  ExecutablePcode(Architecture *g,const string &src,const string &nm);  
  virtual ~ExecutablePcode(void) { if (emitter != (PcodeEmit *)0) delete emitter; }
  virtual string getSource(void) const { return source; }
  uintb evaluate(const vector<uintb> &input);       
};
 
class PcodeInjectLibrary {
protected:
  Architecture *glb;            
  uintb tempbase;           
  vector<InjectPayload *> injection;    
  map<string,int4> callFixupMap;    
  map<string,int4> callOtherFixupMap;   
  map<string,int4> callMechFixupMap;    
  map<string,int4> scriptMap;       
  vector<string> callFixupNames;    
  vector<string> callOtherTarget;   
  vector<string> callMechTarget;    
  vector<string> scriptNames;       
  void registerCallFixup(const string &fixupName,int4 injectid/* , vector<string> targets */);
  void registerCallOtherFixup(const string &fixupName,int4 injectid);
  void registerCallMechanism(const string &fixupName,int4 injectid);
  void registerExeScript(const string &scriptName,int4 injectid);
 
  virtual int4 allocateInject(const string &sourceName,const string &name,int4 type)=0;
 
  virtual void registerInject(int4 injectid)=0;
public:
  PcodeInjectLibrary(Architecture *g,uintb tmpbase) { glb = g; tempbase = tmpbase; }    
  virtual ~PcodeInjectLibrary(void);                
  uintb getUniqueBase(void) const { return tempbase; }      
  int4 getPayloadId(int4 type,const string &nm) const;      
  InjectPayload *getPayload(int4 id) const { return injection[id]; }    
  string getCallFixupName(int4 injectid) const;         
  string getCallOtherTarget(int4 injectid) const;       
  string getCallMechanismName(int4 injectid) const;     
  int4 restoreXmlInject(const string &src,const string &nm,int4 tp,const Element *el);
 
  virtual void restoreDebug(const Element *el) {}
 
  virtual int4 manualCallFixup(const string &name,const string &snippetstring)=0;
 
  virtual int4 manualCallOtherFixup(const string &name,const string &outname,const vector<string> &inname,
                    const string &snippet)=0;
 
  virtual InjectContext &getCachedContext(void)=0;
 
  virtual const vector<OpBehavior *> &getBehaviors(void)=0;
};
 
#endif