mirror of
https://github.com/mirkobrombin/raven.git
synced 2026-11-05 21:56:33 +00:00
99 lines
7.1 KiB
C++
99 lines
7.1 KiB
C++
#include "nt/providers.h"
|
|
#include "objects.h"
|
|
#include "api.h"
|
|
|
|
#include <algorithm>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <stdexcept>
|
|
|
|
static void check(bool value,const char *message)
|
|
{
|
|
if (!value) throw std::runtime_error(message);
|
|
}
|
|
|
|
int main(int argc,char **argv)
|
|
{
|
|
try {
|
|
{
|
|
raven::DesktopObjects objects(sizeof(raven::DesktopDC)+2*sizeof(raven::DesktopRegion)+32);
|
|
raven::DesktopRegion first;first.add({1,2,5,6});
|
|
const auto a=objects.add(first),b=objects.add(raven::DesktopRegion{}),dc=objects.add(raven::DesktopDC{0,0});
|
|
check(a && b && dc && objects.select_clip(dc,first),"clip owner rejected its budgeted snapshot");
|
|
raven::DesktopRegion second;second.add({1,2,5,6});second.add({8,9,12,13});
|
|
const auto used=objects.bytes();
|
|
check(!objects.replace_region(b,second) && objects.bytes()==used && objects.region(b)->empty(),"failed region update damaged state or budget");
|
|
check(!objects.select_clip(dc,second) && objects.bytes()==used && objects.dc(dc)->application_clip->equals(first),"failed clip update damaged its snapshot");
|
|
check(objects.erase(a) && objects.dc(dc)->application_clip->contains(2,3),"deleting the region invalidated a selected copy");
|
|
check(objects.select_clip(dc,std::nullopt) && objects.replace_region(b,first) && objects.erase(dc) && objects.erase(b) &&
|
|
!objects.bytes() && !objects.count(),"region/DC lifetime leaked owned bytes");
|
|
}
|
|
{
|
|
raven::DesktopObjects objects;
|
|
const auto window=objects.add(raven::DesktopWindow{0,1,u"",0,0,16,12});
|
|
const auto bitmap=objects.add(raven::DesktopBitmap{16,12,32,std::vector<uint8_t>(16*12*4)});
|
|
const auto dc=objects.add(raven::DesktopDC{bitmap,bitmap,window});objects.window(window)->dc=dc;
|
|
check(objects.invalidate(window,{1,1,6,6},false) && objects.invalidate(window,{9,7,15,11},false),"paint setup rejected its update regions");
|
|
objects.start_paint(window);raven::DesktopRegion application;application.add({0,0,3,12});
|
|
check(objects.select_clip(dc,application) && objects.dc(dc)->contains(2,2) && !objects.dc(dc)->contains(4,2) &&
|
|
!objects.dc(dc)->contains(0,0),"application clip replaced the paint restriction");
|
|
check(objects.select_clip(dc,std::nullopt) && objects.dc(dc)->contains(4,2) && !objects.dc(dc)->contains(0,0),"removing application clipping escaped BeginPaint");
|
|
objects.finish_paint(window);check(!objects.dc(dc)->clip && !objects.dc(dc)->application_clip,"paint completion retained transient clipping");
|
|
check(objects.erase(dc) && objects.erase(bitmap) && objects.erase(window) && !objects.bytes(),"paint and application clips leaked budget");
|
|
}
|
|
check(argc>=3 && argc<=5,"bootstrap, clipping fixture, optional paint mode and output prefix required");
|
|
const bool paint=argc>=4 && std::string_view(argv[3])=="--paint";
|
|
const char *prefix=paint ? (argc==5 ? argv[4] : nullptr) : (argc==4 ? argv[3] : nullptr);
|
|
std::ifstream file(argv[2],std::ios::binary|std::ios::ate);check(bool(file) && file.tellg()>0,"cannot read clipping fixture");
|
|
std::vector<uint8_t> bytes(size_t(file.tellg()));file.seekg(0);
|
|
check(bool(file.read(reinterpret_cast<char *>(bytes.data()),std::streamsize(bytes.size()))),"short clipping fixture");
|
|
raven::ModuleSet modules;auto &entry=modules.add("clip.exe",bytes);
|
|
unsigned frames=0,removed=0;std::vector<uint8_t> last;raven::DesktopPresentation presentation;
|
|
if(paint){
|
|
presentation.present=[&](uint64_t window,std::string_view title,uint32_t width,uint32_t height,std::span<const uint8_t> pixels){
|
|
check(window && title=="clip paint" && width==16 && height==12 && pixels.size()==16*12*4,"clip paint presentation differs");
|
|
++frames;last.assign(pixels.begin(),pixels.end());
|
|
};
|
|
presentation.remove=[&](uint64_t){++removed;};
|
|
}
|
|
const auto result=raven::run_native_process(modules,entry,argv[1],std::chrono::seconds(20),{},{},presentation);
|
|
if(result.stop!=raven::NativeStop::returned || result.value)std::cerr<<"clipping SDK stop="<<int(result.stop)<<" value="<<result.value<<'\n';
|
|
check(result.stop==raven::NativeStop::returned && !result.value,"clipping SDK contract differs");
|
|
const std::array<std::pair<std::string_view,size_t>,3> outputs=paint ?
|
|
std::array<std::pair<std::string_view,size_t>,3>{{{"paint_rows",8*16*4},{"paint_pixels",16*12*4},{"paint_raw_pixels",16*12*4}}} :
|
|
std::array<std::pair<std::string_view,size_t>,3>{{{"clip_rows",128*16*4},{"clip_pixels",32*16*12*4},{"clip_errors",16*2*4}}};
|
|
for(const auto &[name,size]:outputs) {
|
|
const auto found=std::find_if(entry.exports.begin(),entry.exports.end(),[&](const auto &symbol) {
|
|
return std::find(symbol.names.begin(),symbol.names.end(),name)!=symbol.names.end();
|
|
});check(found!=entry.exports.end(),"clipping evidence export missing");
|
|
const auto data=entry.loaded.data().subspan(found->address,size);
|
|
if(paint && name=="paint_pixels")check(frames>=3 && removed==1 && std::equal(last.begin(),last.end(),data.begin()),"application clipping damaged root presentation or lifetime");
|
|
if(prefix){
|
|
std::ofstream output(std::string(prefix)+"."+std::string(name),std::ios::binary);
|
|
output.write(reinterpret_cast<const char *>(data.data()),std::streamsize(data.size()));check(bool(output),"cannot save clipping evidence");
|
|
}
|
|
}
|
|
auto &gdi=*modules.all().at("gdi32.dll");raven::LoadedImage *images[]={&entry.loaded,&gdi.loaded};
|
|
raven::NativeProcess process(images,argv[1],std::chrono::seconds(3));
|
|
for(const auto &symbol:gdi.exports)process.add_api_trap(raven::api_trap_address(gdi,"gdi32.dll",symbol.names.at(0),symbol.address));
|
|
raven::NativeEnvironment environment(process,entry.loaded.base(),1,1);raven::DesktopObjects objects;
|
|
raven::NativeResources resources(process,environment,modules,entry);raven::NativeDesktop desktop(process,environment,objects,resources);
|
|
const auto call=[&](const char *name,std::initializer_list<uint64_t> arguments){
|
|
const auto function=modules.resolve({"gdi32.dll",name,0,false,0});
|
|
check(process.call(function,std::span(arguments.begin(),arguments.size()),std::chrono::seconds(1)).stop==raven::NativeStop::api,"clip policy API did not trap");
|
|
check(desktop.dispatch(name),"clip policy API not dispatched");const auto run=process.resume(std::chrono::seconds(1));
|
|
check(run.stop==raven::NativeStop::returned,"clip policy API did not return");return run.value;
|
|
};
|
|
const auto region=call("CreateRectRgn",{1,2,5,6});check(region,"clip policy region allocation failed");
|
|
const auto count=objects.count(),used=objects.bytes();environment.set_last_error(71);
|
|
check(!call("CreateRectRgn",{0,0,0x4000000,1}) && environment.last_error()==120 && objects.count()==count && objects.bytes()==used,
|
|
"unsupported region geometry allocated an object");
|
|
environment.set_last_error(71);
|
|
check(!call("OffsetRgn",{region,0x4000000,0}) && environment.last_error()==120 && objects.region(region)->contains(2,3) && objects.bytes()==used,
|
|
"unsupported region offset mutated its source");
|
|
const auto dc=objects.add(raven::DesktopDC{0,0});environment.set_last_error(71);
|
|
check(!call("DPtoLP",{dc,0,65537}) && environment.last_error()==120,"unsupported point count returned success");
|
|
} catch(const std::exception &error){std::cerr<<error.what()<<'\n';return 1;}
|
|
return 0;
|
|
}
|