.Net Core CLR PE 文件启动方法，找到函数入口点，调用整个.Net 程式宿主。
使用方法：可以利用Visual Studio新建一个控制台应用程序，然后生成DLL，替换掉本程序DLL，新建C++ .CPP 文件
然后即可运行看到效果。
整个代码情况如下
包括 IMIAGE_CORE20_HEADER
MetaData, 表格对其方式等待
4 #include "pch.h" 5 #include <iostream> 6 #include <Windows.h> 7 8 #define VAL32(x) x 9 #define VAL16(x) x 10 #define DPTR(type) type* 11 typedef DPTR(IMAGE_DOS_HEADER) PTR_IMAGE_DOS_HEADER; 12 typedef DPTR(IMAGE_NT_HEADERS) PTR_IMAGE_NT_HEADERS; 13 typedef DPTR(IMAGE_NT_HEADERS64) PTR_IMAGE_NT_HEADERS64; 14 typedef ULONG_PTR TADDR; 15 typedef DPTR(IMAGE_DATA_DIRECTORY) PTR_IMAGE_DATA_DIRECTORY; 16 typedef void* PTR_VOID; 17 typedef DPTR(IMAGE_COR20_HEADER) PTR_IMAGE_COR20_HEADER; 18 typedef CONST void far *LPCVOID; 19 20 21 22 23 template <typename Tgt, typename Src> 24 inline Tgt dac_cast(Src src) 25 { 26 #ifdef DACCESS_COMPILE 27 // In DAC builds, first get a TADDR for the source, then create the 28 // appropriate destination instance. 29 TADDR addr = dac_imp::getTaddr(src); 30 return dac_imp::makeDacInst<Tgt>::fromTaddr(addr); 31 #else 32 // In non-DAC builds, dac_cast is the same as a C-style cast because we need to support: 33 // - casting away const 34 // - conversions between pointers and TADDR 35 // Perhaps we should more precisely restrict it's usage, but we get the precise 36 // restrictions in DAC builds, so it wouldn't buy us much. 37 return (Tgt)(src); 38 #endif 39 } 40 TADDR m_base; 41 TADDR m_b; 42 43 44 45 #define ALIGN4BYTE(val) (((val) + 3) & ~0x3) 46 47 struct STORAGEHEADER 48 { 49 public: 50 BYTE fFlags; // STGHDR_xxx flags. 51 BYTE pad; 52 USHORT iStreams; // How many streams are there. 53 public: 54 BYTE GetFlags() 55 { 56 return fFlags; 57 } 58 void SetFlags(BYTE flags) 59 { 60 fFlags = flags; 61 } 62 void AddFlags(BYTE flags) 63 { 64 fFlags |= flags; 65 } 66 67 68 USHORT GetiStreams() 69 { 70 return VAL16(iStreams); 71 } 72 void SetiStreams(USHORT iStreamsCount) 73 { 74 iStreams = VAL16(iStreamsCount); 75 } 76 }; 77 78 struct STORAGESIGNATURE 79 { 80 public: 81 ULONG lSignature; // "Magic" signature. 82 USHORT iMajorVer; // Major file version. 83 USHORT iMinorVer; // Minor file version. 84 ULONG iExtraData; // Offset to next structure of information 85 ULONG iVersionString; // Length of version string 86 public: 87 BYTE pVersion[0]; // Version string 88 ULONG GetSignature() 89 { 90 return VAL32(lSignature); 91 } 92 void SetSignature(ULONG Signature) 93 { 94 lSignature = VAL32(Signature); 95 } 96 97 USHORT GetMajorVer() 98 { 99 return VAL16(iMajorVer); 100 } 101 void SetMajorVer(USHORT MajorVer) 102 { 103 iMajorVer = VAL16(MajorVer); 104 } 105 106 USHORT GetMinorVer() 107 { 108 return VAL16(iMinorVer); 109 } 110 void SetMinorVer(USHORT MinorVer) 111 { 112 iMinorVer = VAL16(MinorVer); 113 } 114 115 ULONG GetExtraDataOffset() 116 { 117 return VAL32(iExtraData); 118 } 119 void SetExtraDataOffset(ULONG ExtraDataOffset) 120 { 121 iExtraData = VAL32(ExtraDataOffset); 122 } 123 124 ULONG GetVersionStringLength() 125 { 126 return VAL32(iVersionString); 127 } 128 void SetVersionStringLength(ULONG VersionStringLength) 129 { 130 iVersionString = VAL32(VersionStringLength); 131 } 132 }; 133 134 struct PSTORAGESIGNATURE 135 { 136 public: 137 ULONG lSignature; // "Magic" signature. 138 USHORT iMajorVer; // Major file version. 139 USHORT iMinorVer; // Minor file version. 140 ULONG iExtraData; // Offset to next structure of information 141 ULONG iVersionString; // Length of version string 142 public: 143 BYTE pVersion[0]; // Version string 144 ULONG GetSignature() 145 { 146 return VAL32(lSignature); 147 } 148 void SetSignature(ULONG Signature) 149 { 150 lSignature = VAL32(Signature); 151 } 152 153 USHORT GetMajorVer() 154 { 155 return VAL16(iMajorVer); 156 } 157 void SetMajorVer(USHORT MajorVer) 158 { 159 iMajorVer = VAL16(MajorVer); 160 } 161 162 USHORT GetMinorVer() 163 { 164 return VAL16(iMinorVer); 165 } 166 void SetMinorVer(USHORT MinorVer) 167 { 168 iMinorVer = VAL16(MinorVer); 169 } 170 171 ULONG GetExtraDataOffset() 172 { 173 return VAL32(iExtraData); 174 } 175 void SetExtraDataOffset(ULONG ExtraDataOffset) 176 { 177 iExtraData = VAL32(ExtraDataOffset); 178 } 179 180 ULONG GetVersionStringLength() 181 { 182 return VAL32(iVersionString); 183 } 184 void SetVersionStringLength(ULONG VersionStringLength) 185 { 186 iVersionString = VAL32(VersionStringLength); 187 } 188 }; 189 190 struct STORAGESTREAM; 191 typedef STORAGESTREAM UNALIGNED * PSTORAGESTREAM; 192 193 194 struct STORAGESTREAM 195 { 196 public: 197 ULONG iOffset; // Offset in file for this stream. 198 ULONG iSize; // Size of the file. 199 char rcName[32]; // Start of name, null terminated. 200 public: 201 // Returns pointer to the next stream. Doesn't validate the structure. 202 inline PSTORAGESTREAM NextStream() 203 { 204 int iLen = (int)(strlen(rcName) + 1); 205 iLen = ALIGN4BYTE(iLen); 206 return ((PSTORAGESTREAM)(((BYTE*)this) + (sizeof(ULONG) * 2) + iLen)); 207 } 208 // Returns pointer to the next stream. 209 // Returns NULL if the structure has invalid format. 210 inline PSTORAGESTREAM NextStream_Verify() 211 { 212 // Check existence of null-terminator in the name 213 if (memchr(rcName, 0, 32) == NULL) 214 { 215 return NULL; 216 } 217 return NextStream(); 218 } 219 220 inline ULONG GetStreamSize() 221 { 222 return (ULONG)(strlen(rcName) + 1 + (sizeof(STORAGESTREAM) - sizeof(rcName))); 223 } 224 225 inline char* GetName() 226 { 227 return rcName; 228 } 229 inline LPCWSTR GetName(__inout_ecount(iMaxSize) LPWSTR szName, int iMaxSize) 230 { 231 //VERIFY(::WszMultiByteToWideChar(CP_ACP, 0, rcName, -1, szName, iMaxSize)); 232 return (szName); 233 } 234 inline void SetName(LPCWSTR szName) 235 { 236 int size; 237 //size = WszWideCharToMultiByte(CP_ACP, 0, szName, -1, rcName, MAXSTREAMNAME, 0, 0); 238 _ASSERTE(size > 0); 239 } 240 241 ULONG GetSize() 242 { 243 return VAL32(iSize); 244 } 245 void SetSize(ULONG Size) 246 { 247 iSize = VAL32(Size); 248 } 249 250 ULONG GetOffset() 251 { 252 return VAL32(iOffset); 253 } 254 void SetOffset(ULONG Offset) 255 { 256 iOffset = VAL32(Offset); 257 } 258 }; 259 260 261 #define UI64_HELPER(x) x ## ui64 262 #define UI64(x) UI64_HELPER(x) 263 264 class CMiniMdSchemaBase 265 { 266 public: 267 ULONG m_ulReserved; // Reserved, must be zero. 268 BYTE m_major; // Version numbers. 269 BYTE m_minor; 270 BYTE m_heaps; // Bits for heap sizes. 271 BYTE m_rid; // log-base-2 of largest rid. 272 273 // Bits for heap sizes. 274 enum { 275 HEAP_STRING_4 = 0x01, 276 HEAP_GUID_4 = 0x02, 277 HEAP_BLOB_4 = 0x04, 278 279 PADDING_BIT = 0x08, // Tables can be created with an extra bit in columns, for growth. 280 281 DELTA_ONLY = 0x20, // If set, only deltas were persisted. 282 EXTRA_DATA = 0x40, // If set, schema persists an extra 4 bytes of data. 283 HAS_DELETE = 0x80, // If set, this metadata can contain _Delete tokens. 284 }; 285 286 unsigned __int64 m_maskvalid; // Bit mask of present table counts. 287 288 unsigned __int64 m_sorted; // Bit mask of sorted tables. 289 FORCEINLINE bool IsSorted(ULONG ixTbl) 290 { 291 return m_sorted & BIT(ixTbl) ? true : false; 292 } 293 void SetSorted(ULONG ixTbl, int bVal) 294 { 295 if (bVal) m_sorted |= BIT(ixTbl); 296 else m_sorted &= ~BIT(ixTbl); 297 } 298 299 #if BIGENDIAN 300 // Verify that the size hasn't changed (Update if necessary) 301 void ConvertEndianness() 302 { 303 _ASSERTE(sizeof(CMiniMdSchemaBase) == 0x18); 304 m_ulReserved = VAL32(m_ulReserved); 305 m_maskvalid = VAL64(m_maskvalid); 306 m_sorted = VAL64(m_sorted); 307 } 308 #else 309 // Nothing to do on little endian machine 310 void ConvertEndianness() { return; } 311 #endif 312 313 private: 314 FORCEINLINE unsigned __int64 BIT(ULONG ixBit) 315 { 316 _ASSERTE(ixBit < (sizeof(__int64)*CHAR_BIT)); 317 return UI64(1) << ixBit; 318 } 319 320 }; 321 322 typedef enum MetadataVersion 323 { 324 MDVersion1 = 0x00000001, 325 MDVersion2 = 0x00000002, 326 327 // @TODO - this value should be updated when we increase the version number 328 MDDefaultVersion = 0x00000002 329 } MetadataVersion; 330 class CMiniMdSchema : public CMiniMdSchemaBase 331 { 332 public: 333 // These are not all persisted to disk. See LoadFrom() for details. 334 ULONG m_cRecs[45]; // Counts of various tables. 335 336 ULONG m_ulExtra; // Extra data, only persisted if non-zero. (m_heaps&EXTRA_DATA flags) 337 338 ULONG LoadFrom(const void*, ULONG); // Load from a compressed version. Return bytes consumed. 339 ULONG SaveTo(void *); // Store a compressed version. Return bytes used in buffer. 340 __checkReturn 341 HRESULT InitNew(MetadataVersion); 342 }; 343 #define GET_UNALIGNED_32(_pObject) (*(UINT32 UNALIGNED *)(_pObject)) 344 #define GET_UNALIGNED_VAL32(_pObject) VAL32(GET_UNALIGNED_32(_pObject)) 345 346 template<typename T> class ClrSafeInt 347 { 348 public: 349 // Default constructor - 0 value by default 350 ClrSafeInt() : 351 m_value(0), 352 m_overflow(false) 353 COMMA_INDEBUG(m_checkedOverflow(false)) 354 { 355 } 356 357 // Value constructor 358 // This is explicit because otherwise it would be harder to 359 // differentiate between checked and unchecked usage of an operator. 360 // I.e. si + x + y vs. si + ( x + y ) 361 // 362 // Set the m_checkedOverflow bit to true since this is being initialized 363 // with a constant value and we know that it is valid. A scenario in 364 // which this is useful is when an overflow causes a fallback value to 365 // be used: 366 // if (val.IsOverflow()) 367 // val = ClrSafeInt<T>(some_value); 368 explicit ClrSafeInt(T v) : 369 m_value(v), 370 m_overflow(false) 371 COMMA_INDEBUG(m_checkedOverflow(true)) 372 { 373 } 374 375 template <typename U> 376 explicit ClrSafeInt(U u) : 377 m_value(0), 378 m_overflow(false) 379 COMMA_INDEBUG(m_checkedOverflow(false)) 380 { 381 if (!FitsIn<T>(u)) 382 { 383 m_overflow = true; 384 } 385 else 386 { 387 m_value = (T)u; 388 } 389 } 390 391 template <typename U> 392 ClrSafeInt(ClrSafeInt<U> u) : 393 m_value(0), 394 m_overflow(false) 395 COMMA_INDEBUG(m_checkedOverflow(false)) 396 { 397 if (u.IsOverflow() || !FitsIn<T>(u.Value())) 398 { 399 m_overflow = true; 400 } 401 else 402 { 403 m_value = (T)u.Value(); 404 } 405 } 406 407 // Note: compiler-generated copy constructor and assignment operator 408 // are correct for our purposes. 409 410 // Note: The MS compiler will sometimes silently perform value-destroying 411 // conversions when calling the operators below. 412 // Eg. "ClrSafeInt<unsigned> s(0); s += int(-1);" will result in s 413 // having the value 0xffffffff without generating a compile-time warning. 414 // Narrowing conversions are generally level 4 warnings so may or may not 415 // be visible. 416 // 417 // In the original SafeInt class, all operators have an 418 // additional overload that takes an arbitrary type U and then safe 419 // conversions are performed (resulting in overflow whenever the value 420 // cannot be preserved). 421 // We could do the same thing, but currently don't because: 422 // - we don't believe there are common cases where this would result in a 423 // security hole. 424 // - the extra complexity isn't worth the benefits 425 // - it would prevent compiler warnings in the cases we do get warnings for. 426 427 428 // true if there has been an overflow leading up to the creation of this 429 // value, false otherwise. 430 // Note that in debug builds we track whether our client called this, 431 // so we should not be calling this method ourselves from within this class. 432 inline bool IsOverflow() const 433 { 434 INDEBUG(m_checkedOverflow = true; ) 435 return m_overflow; 436 } 437 438 // Get the value of this integer. 439 // Must only be called when IsOverflow()==false. If this is called 440 // on overflow we'll assert in Debug and return 0 in release. 441 inline T Value() const 442 { 443 _ASSERTE_SAFEMATH(m_checkedOverflow); // Ensure our caller first checked the overflow bit 444 _ASSERTE_SAFEMATH(!m_overflow); 445 return m_value; 446 } 447 448 // force the value into the overflow state. 449 inline void SetOverflow() 450 { 451 INDEBUG(this->m_checkedOverflow = false; ) 452 this->m_overflow = true; 453 // incase someone manages to call Value in release mode - should be optimized out 454 this->m_value = 0; 455 } 456 457 458 // 459 // OPERATORS 460 // 461 462 // Addition and multiplication. Only permitted when both sides are explicitly 463 // wrapped inside of a ClrSafeInt and when the types match exactly. 464 // If we permitted a RHS of type 'T', then there would be differences 465 // in correctness between mathematically equivalent expressions such as 466 // "si + x + y" and "si + ( x + y )". Unfortunately, not permitting this 467 // makes expressions involving constants tedius and ugly since the constants 468 // must be wrapped in ClrSafeInt instances. If we become confident that 469 // our tools (PreFast) will catch all integer overflows, then we can probably 470 // safely add this. 471 inline ClrSafeInt<T> operator +(ClrSafeInt<T> rhs) const 472 { 473 ClrSafeInt<T> result; // value is initialized to 0 474 if (this->m_overflow || 475 rhs.m_overflow || 476 !addition(this->m_value, rhs.m_value, result.m_value)) 477 { 478 result.m_overflow = true; 479 } 480 481 return result; 482 } 483 484 inline ClrSafeInt<T> operator -(ClrSafeInt<T> rhs) const 485 { 486 ClrSafeInt<T> result; // value is initialized to 0 487 if (this->m_overflow || 488 rhs.m_overflow || 489 !subtraction(this->m_value, rhs.m_value, result.m_value)) 490 { 491 result.m_overflow = true; 492 } 493 494 return result; 495 } 496 497 inline ClrSafeInt<T> operator *(ClrSafeInt<T> rhs) const 498 { 499 ClrSafeInt<T> result; // value is initialized to 0 500 if (this->m_overflow || 501 rhs.m_overflow || 502 !multiply(this->m_value, rhs.m_value, result.m_value)) 503 { 504 result.m_overflow = true; 505 } 506 507 return result; 508 } 509 510 // Accumulation operators 511 // Here it's ok to have versions that take a value of type 'T', however we still 512 // don't allow any mixed-type operations. 513 inline ClrSafeInt<T>& operator +=(ClrSafeInt<T> rhs) 514 { 515 INDEBUG(this->m_checkedOverflow = false; ) 516 if (this->m_overflow || 517 rhs.m_overflow || 518 !ClrSafeInt<T>::addition(this->m_value, rhs.m_value, this->m_value)) 519 { 520 this->SetOverflow(); 521 } 522 return *this; 523 } 524 525 inline ClrSafeInt<T>& operator +=(T rhs) 526 { 527 INDEBUG(this->m_checkedOverflow = false; ) 528 if (this->m_overflow || 529 !ClrSafeInt<T>::addition(this->m_value, rhs, this->m_value)) 530 { 531 this->SetOverflow(); 532 } 533 return *this; 534 } 535 536 inline ClrSafeInt<T>& operator *=(ClrSafeInt<T> rhs) 537 { 538 INDEBUG(this->m_checkedOverflow = false; ) 539 if (this->m_overflow || 540 rhs.m_overflow || 541 !ClrSafeInt<T>::multiply(this->m_value, rhs.m_value, this->m_value)) 542 { 543 this->SetOverflow(); 544 } 545 return *this; 546 } 547 548 inline ClrSafeInt<T>& operator *=(T rhs) 549 { 550 INDEBUG(this->m_checkedOverflow = false; ) 551 if (this->m_overflow || 552 !ClrSafeInt<T>::multiply(this->m_value, rhs, this->m_value)) 553 { 554 this->SetOverflow(); 555 } 556 557 return *this; 558 } 559 560 // 561 // STATIC HELPER METHODS 562 //these compile down to something as efficient as macros and allow run-time testing 563 //of type by the developer 564 // 565 566 template <typename U> static bool IsSigned(U) 567 { 568 return std::is_signed<U>::value; 569 } 570 571 static bool IsSigned() 572 { 573 return std::is_signed<T>::value; 574 } 575 576 static bool IsMixedSign(T lhs, T rhs) 577 { 578 return ((lhs ^ rhs) < 0); 579 } 580 581 static unsigned char BitCount() { return (sizeof(T) * 8); } 582 583 static bool Is64Bit() { return sizeof(T) == 8; } 584 static bool Is32Bit() { return sizeof(T) == 4; } 585 static bool Is16Bit() { return sizeof(T) == 2; } 586 static bool Is8Bit() { return sizeof(T) == 1; } 587 588 //both of the following should optimize away 589 static T MaxInt() 590 { 591 if (IsSigned()) 592 { 593 return (T)~((T)1 << (BitCount() - 1)); 594 } 595 //else 596 return (T)(~(T)0); 597 } 598 599 static T MinInt() 600 { 601 if (IsSigned()) 602 { 603 return (T)((T)1 << (BitCount() - 1)); 604 } 605 else 606 { 607 return ((T)0); 608 } 609 } 610 611 // Align a value up to the nearest boundary, which must be a power of 2 612 inline void AlignUp(T alignment) 613 { 614 _ASSERTE_SAFEMATH(IsPowerOf2(alignment)); 615 *this += (alignment - 1); 616 if (!this->m_overflow) 617 { 618 m_value &= ~(alignment - 1); 619 } 620 } 621 622 // 623 // Arithmetic implementation functions 624 // 625 626 //note - this looks complex, but most of the conditionals 627 //are constant and optimize away 628 //for example, a signed 64-bit check collapses to: 629 /* 630 if(lhs == 0 || rhs == 0) 631 return 0; 632 633 if(MaxInt()/+lhs < +rhs) 634 { 635 //overflow 636 throw SafeIntException(ERROR_ARITHMETIC_OVERFLOW); 637 } 638 //ok 639 return lhs * rhs; 640 641 Which ought to inline nicely 642 */ 643 // Returns true if safe, false for overflow. 644 static bool multiply(T lhs, T rhs, T &result) 645 { 646 if (Is64Bit()) 647 { 648 //fast track this one - and avoid DIV_0 below 649 if (lhs == 0 || rhs == 0) 650 { 651 result = 0; 652 return true; 653 } 654 655 //we're 64 bit - slow, but the only way to do it 656 if (IsSigned()) 657 { 658 if (!IsMixedSign(lhs, rhs)) 659 { 660 //both positive or both negative 661 //result will be positive, check for lhs * rhs > MaxInt 662 if (lhs > 0) 663 { 664 //both positive 665 if (MaxInt() / lhs < rhs) 666 { 667 //overflow 668 return false; 669 } 670 } 671 else 672 { 673 //both negative 674 675 //comparison gets tricky unless we force it to positive 676 //EXCEPT that -MinInt is undefined - can't be done 677 //And MinInt always has a greater magnitude than MaxInt 678 if (lhs == MinInt() || rhs == MinInt()) 679 { 680 //overflow 681 return false; 682 } 683 684 #ifdef _MSC_VER 685 #pragma warning( disable : 4146 ) // unary minus applied to unsigned is still unsigned 686 #endif 687 if (MaxInt() / (-lhs) < (-rhs)) 688 { 689 //overflow 690 return false; 691 } 692 #ifdef _MSC_VER 693 #pragma warning( default : 4146 ) 694 #endif 695 } 696 } 697 else 698 { 699 //mixed sign - this case is difficult 700 //test case is lhs * rhs < MinInt => overflow 701 //if lhs < 0 (implies rhs > 0), 702 //lhs < MinInt/rhs is the correct test 703 //else if lhs > 0 704 //rhs < MinInt/lhs is the correct test 705 //avoid dividing MinInt by a negative number, 706 //because MinInt/-1 is a corner case 707 708 if (lhs < 0) 709 { 710 if (lhs < MinInt() / rhs) 711 { 712 //overflow 713 return false; 714 } 715 } 716 else 717 { 718 if (rhs < MinInt() / lhs) 719 { 720 //overflow 721 return false; 722 } 723 } 724 } 725 726 //ok 727 result = lhs * rhs; 728 return true; 729 } 730 else 731 { 732 //unsigned, easy case 733 if (MaxInt() / lhs < rhs) 734 { 735 //overflow 736 return false; 737 } 738 //ok 739 result = lhs * rhs; 740 return true; 741 } 742 } 743 else if (Is32Bit()) 744 { 745 //we're 32-bit 746 if (IsSigned()) 747 { 748 INT64 tmp = (INT64)lhs * (INT64)rhs; 749 750 //upper 33 bits must be the same 751 //most common case is likely that both are positive - test first 752 if ((tmp & 0xffffffff80000000LL) == 0 || 753 (tmp & 0xffffffff80000000LL) == 0xffffffff80000000LL) 754 { 755 //this is OK 756 result = (T)tmp; 757 return true; 758 } 759 760 //overflow 761 return false; 762 763 } 764 else 765 { 766 UINT64 tmp = (UINT64)lhs * (UINT64)rhs; 767 if (tmp & 0xffffffff00000000ULL) //overflow 768 { 769 //overflow 770 return false; 771 } 772 result = (T)tmp; 773 return true; 774 } 775 } 776 else if (Is16Bit()) 777 { 778 //16-bit 779 if (IsSigned()) 780 { 781 INT32 tmp = (INT32)lhs * (INT32)rhs; 782 //upper 17 bits must be the same 783 //most common case is likely that both are positive - test first 784 if ((tmp & 0xffff8000) == 0 || (tmp & 0xffff8000) == 0xffff8000) 785 { 786 //this is OK 787 result = (T)tmp; 788 return true; 789 } 790 791 //overflow 792 return false; 793 } 794 else 795 { 796 UINT32 tmp = (UINT32)lhs * (UINT32)rhs; 797 if (tmp & 0xffff0000) //overflow 798 { 799 return false; 800 } 801 result = (T)tmp; 802 return true; 803 } 804 } 805 else //8-bit 806 { 807 _ASSERTE_SAFEMATH(Is8Bit()); 808 809 if (IsSigned()) 810 { 811 INT16 tmp = (INT16)lhs * (INT16)rhs; 812 //upper 9 bits must be the same 813 //most common case is likely that both are positive - test first 814 if ((tmp & 0xff80) == 0 || (tmp & 0xff80) == 0xff80) 815 { 816 //this is OK 817 result = (T)tmp; 818 return true; 819 } 820 821 //overflow 822 return false; 823 } 824 else 825 { 826 UINT16 tmp = ((UINT16)lhs) * ((UINT16)rhs); 827 828 if (tmp & 0xff00) //overflow 829 { 830 return false; 831 } 832 result = (T)tmp; 833 return true; 834 } 835 } 836 } 837 838 // Returns true if safe, false on overflow 839 static inline bool addition(T lhs, T rhs, T &result) 840 { 841 if (IsSigned()) 842 { 843 //test for +/- combo 844 if (!IsMixedSign(lhs, rhs)) 845 { 846 //either two negatives, or 2 positives 847 #ifdef __GNUC__ 848 // Workaround for GCC warning: "comparison is always 849 // false due to limited range of data type." 850 if (!(rhs == 0 || rhs > 0)) 851 #else 852 if (rhs < 0) 853 #endif // __GNUC__ else 854 { 855 //two negatives 856 if (lhs < (T)(MinInt() - rhs)) //remember rhs < 0 857 { 858 return false; 859 } 860 //ok 861 } 862 else 863 { 864 //two positives 865 if ((T)(MaxInt() - lhs) < rhs) 866 { 867 return false; 868 } 869 //OK 870 } 871 } 872 //else overflow not possible 873 result = lhs + rhs; 874 return true; 875 } 876 else //unsigned 877 { 878 if ((T)(MaxInt() - lhs) < rhs) 879 { 880 return false; 881 882 } 883 result = lhs + rhs; 884 return true; 885 } 886 } 887 888 // Returns true if safe, false on overflow 889 static inline bool subtraction(T lhs, T rhs, T& result) 890 { 891 T tmp = lhs - rhs; 892 893 if (IsSigned()) 894 { 895 if (IsMixedSign(lhs, rhs)) //test for +/- combo 896 { 897 //mixed positive and negative 898 //two cases - +X - -Y => X + Y - check for overflow against MaxInt() 899 // -X - +Y - check for overflow against MinInt() 900 901 if (lhs >= 0) //first case 902 { 903 //test is X - -Y > MaxInt() 904 //equivalent to X > MaxInt() - |Y| 905 //Y == MinInt() creates special case 906 //Even 0 - MinInt() can't be done 907 //note that the special case collapses into the general case, due to the fact 908 //MaxInt() - MinInt() == -1, and lhs is non-negative 909 //OR tmp should be GTE lhs 910 911 // old test - leave in for clarity 912 //if(lhs > (T)(MaxInt() + rhs)) //remember that rhs is negative 913 if (tmp < lhs) 914 { 915 return false; 916 } 917 //fall through to return value 918 } 919 else 920 { 921 //second case 922 //test is -X - Y < MinInt() 923 //or -X < MinInt() + Y 924 //we do not have the same issues because abs(MinInt()) > MaxInt() 925 //tmp should be LTE lhs 926 927 //if(lhs < (T)(MinInt() + rhs)) // old test - leave in for clarity 928 if (tmp > lhs) 929 { 930 return false; 931 } 932 //fall through to return value 933 } 934 } 935 // else 936 //both negative, or both positive 937 //no possible overflow 938 result = tmp; 939 return true; 940 } 941 else 942 { 943 //easy unsigned case 944 if (lhs < rhs) 945 { 946 return false; 947 } 948 result = tmp; 949 return true; 950 } 951 } 952 953 private: 954 // Private helper functions 955 // Note that's it occasionally handy to call the arithmetic implementation 956 // functions above so we leave them public, even though we almost always use 957 // the operators instead. 958 959 // True if the specified value is a power of two. 960 static inline bool IsPowerOf2(T x) 961 { 962 // find the smallest power of 2 >= x 963 T testPow = 1; 964 while (testPow < x) 965 { 966 testPow = testPow << 1; // advance to next power of 2 967 if (testPow <= 0) 968 { 969 return false; // overflow 970 } 971 } 972 973 return(testPow == x); 974 } 975 976 // 977 // Instance data 978 // 979 980 // The integer value this instance represents, or 0 if overflow. 981 T m_value; 982 983 // True if overflow has been reached. Once this is set, it cannot be cleared. 984 bool m_overflow; 985 986 // In debug builds we verify that our caller checked the overflow bit before 987 // accessing the value. This flag is cleared on initialization, and whenever 988 // m_value or m_overflow changes, and set only when IsOverflow 989 // is called. 990 INDEBUG(mutable bool m_checkedOverflow; ) 991 }; 992 993 ULONG 994 CMiniMdSchema::LoadFrom( 995 const void *pvData, // Data to load from. 996 ULONG cbData) // Amount of data available. 997 { 998 ULONG ulData; // Bytes consumed. 999 1000 ulData = sizeof(CMiniMdSchemaBase); 1001 1002 // Be sure we can get the base part. 1003 if (cbData < ulData) 1004 return (ULONG)(-1); 1005 1006 // Transfer the fixed fields. The (void*) casts prevents the compiler 1007 // from making bad assumptions about the alignment. 1008 memcpy((void *)this, (void *)pvData, sizeof(CMiniMdSchemaBase)); 1009 static_cast<CMiniMdSchemaBase*>(this)->ConvertEndianness(); 1010 1011 unsigned __int64 maskvalid = m_maskvalid; 1012 1013 // Transfer the variable fields. 1014 memset(m_cRecs, 0, sizeof(m_cRecs)); 1015 int iDst; 1016 for (iDst = 0; iDst < 45; ++iDst, maskvalid >>= 1) 1017 { 1018 if ((maskvalid & 1) != 0) 1019 { 1020 // Check integer overflow for: ulData + sizeof(UINT32) 1021 ULONG ulDataTemp; 1022 if (!ClrSafeInt<ULONG>::addition(ulData, sizeof(UINT32), ulDataTemp)) 1023 { 1024 return (ULONG)(-1); 1025 } 1026 // Verify that the data is there before touching it. 1027 if (cbData < (ulData + sizeof(UINT32))) 1028 return (ULONG)(-1); 1029 1030 m_cRecs[iDst] = GET_UNALIGNED_VAL32((const BYTE *)pvData + ulData); 1031 // It's safe to sum, because we checked integer overflow above 1032 ulData += sizeof(UINT32); 1033 } 1034 } 1035 // Also accumulate the sizes of any counters that we don't understand. 1036 1037 1038 // Retrieve the extra 4 bytes data. 1039 // Did we go past end of buffer? 1040 if (cbData < ulData) 1041 return (ULONG)(-1); 1042 1043 return ulData; 1044 } // CMiniMdSchema::LoadFrom 1045 1046 int main() 1047 { 1048 HMODULE HE=LoadLibraryExW(L"C:\Users\Administrator\Desktop\Consletest\ConsoleApp5.dll", NULL, 8); 1049 //0x00007ff82c940000 1050 //0x00007ff82e1c0000 1051 1052 m_base=TADDR((void *)HE); 1053 1054 IMAGE_DOS_HEADER *SR =dac_cast<PTR_IMAGE_DOS_HEADER>(PTR_IMAGE_DOS_HEADER(HE)); 1055 1056 IMAGE_NT_HEADERS *HR =dac_cast<PTR_IMAGE_NT_HEADERS64>(PTR_IMAGE_NT_HEADERS(m_base + VAL32(SR->e_lfanew))); 1057 1058 IMAGE_DATA_DIRECTORY *pDir=dac_cast<PTR_IMAGE_DATA_DIRECTORY>(dac_cast<TADDR>(dac_cast<PTR_IMAGE_NT_HEADERS64>(PTR_IMAGE_NT_HEADERS(m_base + VAL32(PTR_IMAGE_DOS_HEADER(HE)->e_lfanew)))) + 1059 offsetof(IMAGE_NT_HEADERS64, OptionalHeader.DataDirectory) + 14 * sizeof(IMAGE_DATA_DIRECTORY)); 1060 1061 1062 IMAGE_COR20_HEADER *OR = PTR_IMAGE_COR20_HEADER(m_base + VAL32(pDir->VirtualAddress)); 1063 1064 IMAGE_DATA_DIRECTORY *DR =&(OR->MetaData); 1065 1066 const void* pMeta = NULL; 1067 1068 pMeta=dac_cast<PTR_VOID>(VAL32(m_base+DR->VirtualAddress)); 1069 1070 ULONG cbStreamBuffer; 1071 1072 const BYTE *pbMd; 1073 1074 pbMd = (const BYTE *)pMeta; 1075 1076 1077 pbMd += sizeof(STORAGESIGNATURE); 1078 1079 ULONG cbVersionString = ((STORAGESIGNATURE *)pMeta)->GetVersionStringLength(); 1080 1081 pbMd += cbVersionString; 1082 1083 pbMd += sizeof(STORAGEHEADER); 1084 1085 PSTORAGESTREAM pStream; 1086 1087 pStream = (PSTORAGESTREAM)pbMd; 1088 1089 int i; 1090 CMiniMdSchema m_Schema; 1091 ULONG cbData; 1092 ULONG cb; 1093 for (i = 0; i < 5; i++) 1094 { 1095 void *pvCurrentData = (void *)((BYTE *)pMeta + pStream->GetOffset()); 1096 1097 ULONG cbCurrentData = pStream->GetSize(); 1098 1099 PSTORAGESTREAM pNext = pStream->NextStream_Verify(); 1100 1101 if (pStream->GetName() == "#~") 1102 { 1103 cbData = sizeof(CMiniMdSchemaBase); 1104 cb=m_Schema.LoadFrom(pvCurrentData, cbCurrentData); 1105 } 1106 pStream = pNext; 1107 } 1108 1109 1110 std::cout << "Hello World! "; 1111 }