Home / Questions / 266483
Accepted
PaperBirdMaster
Asked: 2020-05-25 02:14:29 +0800 CST 2020-05-25 02:14:29 +0800 CST

Access private data of an object

  • 772

We have started working on a project that uses a library that we are not allowed to modify . We find ourselves with the problem that we need to change the internal state of some objects of this library but the interface of these objects does not offer methods for it:

class Clase
{
    std::string dato1;
    std::string dato2;
public:
    void actualiza1(std::string valor) { dato1 = valor; }
};

As can be seen in the simplified example, we can change Clase::dato1but we have no way to modify Clase::dato2:

Clase c;
c.actualiza1("Dato 1"); // Correcto.
c.dato2 = "Dato 2";     // Error! dato2 es privado!

We have tried to change the data using a pointer, but it has not been possible either:

Clase c;

using str_pClase = std::string Clase::*;
str_pClase p2 = &Clase::dato2; // Error! dato2 es privado;

c.*p2 = "Dato 2";

As a last resort we have copied the drafting of the library objects but with the public members, when we need to change the internal state of the object we use the newplacement state:

class Clase
{
    std::string dato1;
    std::string dato2;
public:
    void actualiza1(std::string valor) { dato1 = valor; }
};

struct Estructura
{
    std::string dato1;
    std::string dato2;
};

Clase c;
c.actualiza1("Dato 1"); // Correcto.

Estructura *e = new(&c) Estructura;
e->dato2 = "Dato 2";    // Correcto! c.dato2 ahora es 200;

Although this seems to work, it causes other bugs as when building an object on top of an existing one, the sub-object's constructors are called and change (initialize) values ​​of the original object that we didn't want to be modified.

Is it possible to somehow bypass the data access restriction?

Based on this SOen question

c++

1 Answers

  1. Best Answer

    Is it possible to somehow bypass the data access restriction?

    No. What you're trying to do is dangerous and against C++ standards.

    Well, C++ ignores access restrictions in a specific context: The explicit instantiation of a template. This means that by explicitly instantiating a template we can access private and protected object data; the most practical would be to capture a pointer to the internal data. But it is not easy.

    If we have an object that nests a member pointer:

    template <typename clase_t, typename miembro_t>
struct puntero_a_miembro
{
    using tipo = miembro_t clase_t::*;
};

    We can use it as a " backdoor " key to an object:

    template <int id, typename llave_t>
struct puerta_trasera
{
    using tipo_t = typename llave_t::tipo;
    inline static tipo_t llave;
};

    To open this backdoor with our key, we need a template that we can explicitly instantiate with explicit parameters:

    template <int id, typename llave_t, typename llave_t::tipo llave>
class abrir : puerta_trasera<id, llave_t>
{
    static inline const int ID = (abrir::puerta_trasera::llave = llave, id);
};

    The above witchcraft is needed to initialize the backdoor key once ( static) per template instance, so with your item Clase, we'll need to open two backdoors:

    class Clase
{
    std::string dato1;
    std::string dato2;
public:
    void actualiza1(std::string valor) { dato1 = valor; }
};

// Instancia explícita de la plantilla 'abrir'
// usando la llave 'std::string' de 'Clase' sobre 'Clase::dato1'.
template class abrir<0, puntero_a_miembro<Clase, std::string>, &Clase::dato1>;
//                       Esto es privado, pero no da error --> ~~~~~~~~~~~~~

// Instancia explícita de la plantilla 'abrir'
// usando la llave 'std::string' de 'Clase' sobre 'Clase::dato2'.
template class abrir<1, puntero_a_miembro<Clase, std::string>, &Clase::dato2>;
//                       Esto es privado, pero no da error --> ~~~~~~~~~~~~~

    In the context of explicit template instantiation, access permissions are not checked, so we can access Clase::dato1y Clase::dato2like so:

    int main()
{
    Clase a, b;

    // Acceso al miembro Clase::dato1 de la instancia 'a'
    a.*puerta_trasera<0, puntero_a_miembro<std::string, Clase>>::llave = "Dato 1";
    // Acceso al miembro Clase::dato2 de la instancia 'a'
    a.*puerta_trasera<1, puntero_a_miembro<std::string, Clase>>::llave = "Dato 2";
    // Acceso al miembro Clase::dato1 de la instancia 'b'
    b.*puerta_trasera<0, puntero_a_miembro<std::string, Clase>>::llave = "Dato 1";
    // Acceso al miembro Clase::dato2 de la instancia 'b'
    b.*puerta_trasera<1, puntero_a_miembro<std::string, Clase>>::llave = "Dato 2";

    return 0;
}

    The syntax is quite cumbersome, so it would be appropriate to use a template helper function:

    template <int id, typename retorno_t, typename clase_t>
retorno_t &accede(clase_t &clase)
{
    return clase.*puerta_trasera<id, puntero_a_miembro<clase_t, retorno_t>>::llave;
}

    In case you want to call private methods, you can also declare a helper template function:

    template <int id, typename retorno_t, typename clase_t, typename ... parametros_t>
retorno_t llama(clase_t &clase, parametros_t ... parametros)
{
    return (clase.*puerta_trasera<id, puntero_a_miembro<clase_t, retorno_t(parametros_t ...)>>::llave)(parametros ...);
}

    With these helper functions, backdoor access to private data would look like this:

    class Clase
{
    std::string dato1;
    std::string dato2;
    void funcion_privada1();
    int funcion_privada2(int, int);
};

template class abrir<0, puntero_a_miembro<Clase, std::string>, &Clase::dato1>;
template class abrir<1, puntero_a_miembro<Clase, std::string>, &Clase::dato2>;
template class abrir<0, puntero_a_miembro<Clase, void()>, &Clase::funcion_privada1>;
template class abrir<0, puntero_a_miembro<Clase, int(int, int)>, &Clase::funcion_privada2>;

int main()
{
    Clase a, b;

    accede<0, int>(a) = "Dato 1";
    accede<0, int>(b) = "Dato 1";
    accede<1, int>(a) = "Dato 2";
    accede<1, int>(b) = "Dato 2";

    llama<0, void>(a);
    llama<0, int>(b, 1, 2);

    return 0;
}

    You can see the code working on Wandbox .

    • 8