zjgcjy/pykd
1
0
Fork 0
mirror of https://github.com/ivellioscolin/pykd.git synced 2025-04-21 12:53:23 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

[0.3.x] added : check integer overflow for NumVariabt class

Browse Source 
git-svn-id: https://pykd.svn.codeplex.com/svn@90962 9b283d60-5439-405e-af05-b73fd8c4d996
This commit is contained in:
SND\kernelnet_cp 2016-03-17 08:16:06 +00:00 committed by Mikhail I. Izmestev
parent 2f192bbd01
commit 6b90cf1c99
3 changed files with 54 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
pykd/dbgexcept.h
View File

@ -9,6 +9,13 @@
namespace pykd {
class OverflowException : public std::exception
{
public:
OverflowException(const char* desc) : std::exception(desc)
{}
};
template< class TExcept >
struct exceptPyType{
@ -48,8 +55,7 @@ public:
};
inline void exceptionTranslate(const kdlib::DbgException &e )
inline void dbgExceptionTranslate(const kdlib::DbgException &e)
{
if ( typeid(e).hash_code() == typeid(kdlib::MemoryException).hash_code() )
{
@ -82,6 +88,16 @@ inline void exceptionTranslate(const kdlib::DbgException &e )
PyErr_SetObject( exceptPyType<kdlib::DbgException>::pyExceptType.get(), exceptObj.ptr());
}
inline void pykdExceptionTranslate(const std::exception &e)
{
if (typeid(e).hash_code() == typeid(OverflowException).hash_code())
{
PyErr_SetString(PyExc_OverflowError, e.what());
return;
}
}
inline void registerExceptions()
{
pykd::exception<kdlib::DbgException>( "DbgException", "Pykd base exception class" );
@ -89,7 +105,8 @@ inline void registerExceptions()
pykd::exception<kdlib::SymbolException,kdlib::DbgException>( "SymbolException", "Symbol exception" );
pykd::exception<kdlib::TypeException,kdlib::SymbolException>( "TypeException", "type exception" );
python::register_exception_translator<kdlib::DbgException>( &exceptionTranslate );
python::register_exception_translator<kdlib::DbgException>( &dbgExceptionTranslate );
python::register_exception_translator<OverflowException>( &pykdExceptionTranslate );
}
/////////////////////////////////////////////////////////////////////////////////////

28
pykd/variant.h
View File

@ -4,6 +4,7 @@
#include "kdlib/variant.h"
#include "kdlib/exceptions.h"
#include "dbgexcept.h"
namespace pykd {
@ -13,13 +14,13 @@ class NumVariantAdaptor : public kdlib::NumBehavior
public:
static kdlib::NumBehavior* NumVariantAdaptor::getVariant( const python::object &obj )
static kdlib::NumBehavior* NumVariantAdaptor::getVariant(const python::object &obj)
{
NumVariantAdaptor* var = new NumVariantAdaptor();
if ( PyBool_Check( obj.ptr() ) )
if (PyBool_Check(obj.ptr()))
{
if ( obj.ptr() == Py_True )
if (obj.ptr() == Py_True)
var->m_variant.setBool(true);
else
var->m_variant.setBool(false);
@ -34,17 +35,28 @@ public:
#if PY_VERSION_HEX < 0x03000000
if ( PyInt_CheckExact( obj.ptr() ) )
if (PyInt_CheckExact(obj.ptr()))
{
var->m_variant.setLong( PyLong_AsLong( obj.ptr() ) );
var->m_variant.setLong(PyLong_AsLong(obj.ptr()));
return var;
}
#endif
if ( _PyLong_Sign( obj.ptr() ) >= 0 )
var->m_variant.setULongLong( PyLong_AsUnsignedLongLong( obj.ptr() ) );
if (_PyLong_Sign(obj.ptr()) >= 0)
{
if (_PyLong_NumBits(obj.ptr()) > 64)
throw pykd::OverflowException("int too big to convert");
var->m_variant.setULongLong(PyLong_AsUnsignedLongLong(obj.ptr()));
}
else
var->m_variant.setLongLong( PyLong_AsLongLong( obj.ptr() ) );
{
if (_PyLong_NumBits(obj.ptr()) > 63)
throw pykd::OverflowException("int too big to convert");
var->m_variant.setLongLong(PyLong_AsLongLong(obj.ptr()));
}
return var;
}

14
test/scripts/intbase.py
View File

@ -1,6 +1,7 @@
import unittest
import target
import sys
from pykd import numVariant
class IntBaseTest( unittest.TestCase ):
@ -15,9 +16,12 @@ class IntBaseTest( unittest.TestCase ):
a = numVariant(-2000)
a = numVariant(-200000)
a = numVariant(-20000000000)
a = numVariant(-0xFFFFFFFFFFFFFFFF )
a = numVariant( True )
self.assertRaises(OverflowError, numVariant, -0xFFFFFFFFFFFFFFFF )
self.assertRaises(OverflowError, numVariant, 0x10000000000000000 )
def testEq( self ):
self.assertTrue( 0xFF == numVariant(0xFF) and numVariant(0xFF) == 0xFF )
self.assertTrue( 0xFFFF == numVariant(0xFFFF) and 0xFFFF == numVariant(0xFFFF) )
@ -28,7 +32,7 @@ class IntBaseTest( unittest.TestCase ):
self.assertTrue( -2000 == numVariant(-2000) )
self.assertTrue( -0x7FFFFFFF == numVariant(-0x7FFFFFFF) )
self.assertTrue( -20000000000 == numVariant(-20000000000) )
self.assertTrue( -0x8000000000000000 == numVariant(-0x8000000000000000) )
self.assertTrue( -0x7fffffffffffffff == numVariant(-0x7fffffffffffffff) )
#self.assertTrue( numVariant(0x20L) == numVariant(0x20) )
self.assertTrue( True == numVariant(True) )
self.assertTrue( False == numVariant(0) )
@ -44,7 +48,7 @@ class IntBaseTest( unittest.TestCase ):
self.assertTrue( -20 + 1 != numVariant(-20) )
self.assertTrue( -2000 + 1 != numVariant(-2000) )
self.assertTrue( -20000000000 + 1 != numVariant(-20000000000) )
self.assertTrue( -0x8000000000000000 - 1 != numVariant(-0x8000000000000000) )
self.assertTrue( -0x8000000000000000 - 1 != numVariant(-0x7fffffffffffffff) )
self.assertTrue( numVariant(1) != numVariant(2) )
def testLtGt( self ):
@ -73,8 +77,8 @@ class IntBaseTest( unittest.TestCase ):
self.assertEqual( -20, numVariant(-10) + (-10) )
self.assertEqual( 10, numVariant(-10) + 20 )
self.assertEqual( 0x7fffffffffffffff + 1, numVariant(0x7fffffffffffffff) + 1)
self.assertEqual( -0x8000000000000000 + 10, numVariant(-0x8000000000000000) + 10 )
self.assertEqual( 0, numVariant(-0x8000000000000000) + 0x8000000000000000 )
self.assertEqual( -0x7fffffffffffffff + 10, numVariant(-0x7fffffffffffffff) + 10 )
self.assertEqual( 0, numVariant(-0x7fffffffffffffff) + 0x7fffffffffffffff )
self.assertEqual( 5, numVariant(3) + numVariant(2) )
def testSub( self ):