Los contratos inteligentes o smart contracts son cadenas de bloques que se ejecutan cuando se cierra un acuerdo que cumple con ciertas condiciones establecidas, entre dos o más partes, y no necesita de una entidad o un tercero para ser aprobado. La identidad digital de una persona o una empresa puede ser representada por uno o más contratos inteligentes.
Autenticación vs. Autorización
Autenticación y autorización son dos palabras similares que podemos confundir, pero que en realidad no son sinónimos ni guardan relación.
Autenticación: demostrar que soy, quien digo que soy, para acceder a un lugar.
Autorización: una vez que demuestre quien soy y puedo acceder, tengo que demostrar qué permisos o accesos tengo para acceder en determinado lugar.
La Autenticación nos identifica y la Autorización nos da los privilegio o no para llegar hasta determinado punto de un sistema o lugar.
Autenticación y Autorización en Blockchain
En una Blockchain, a través de la dirección de una wallet, podemos determinar quién es el que realiza la transacción, puesto que esta solo puede ser firmada con una clave privada de la cuenta. La criptografía es el poderoso mecanismo que permite asegurar la identidad de una cuenta y que nadie más pueda falsificarla.
Autenticación de usuarios
Podemos representar y validar la autenticación de un usuario de forma muy sencilla en un contrato inteligente.
// SPDX-License-Identifier: GPL-3.0pragma solidity >=0.7.0<0.9.0;contract Authentication {mapping(address => bool) public users; function authenticate() public { users[msg.sender]= true;}}
Guardamos en un mapping una relación entre una dirección y un booleano. Si una cuenta se autenticó previamente, podremos comprobarlo.
Lo importante aquí es que solo el dueño de la cuenta pueda poner en true el booleano que le corresponde a su dirección llamando a la función authenticate().
Autorización de usuarios
La autorización siempre es algo más compleja. Requiere llevar un registro de qué puede y qué no puede hacer un usuario.
contract Identity {structBasicInfo{ string name; string email;}structPersonalInfo{ uint256 salary; string _address;}enumUserType{ Basic, Personal
} error UserUnauthorized(address user, UserType userType);// Variables para guardar información de la cuenta BasicInfo private basicInfo; PersonalInfo private personalInfo; address private owner;// Mapping para otorgar permisos de lectura a otras cuentasmapping(address => bool) private basicUsers;mapping(address => bool) private personalUsers;constructor(string memory name, string memory email, uint256 salary, string memory _address){ basicInfo =BasicInfo(name, email); personalInfo =PersonalInfo(salary, _address); owner = msg.sender;}// Verificador de Autorización del usuario modifier authorizeUser(UserType userType){if(msg.sender == owner || personalUsers[msg.sender]){ _;}elseif(userType == UserType.Basic && basicUsers[msg.sender]){ _;}else{ revert UserUnauthorized(msg.sender, userType);}}// Solo el owner puede otorgar permisos a otras cuentas modifier onlyOwner(){require(msg.sender == owner,"Only owner can authorize users"); _;}// Otorgamos permisos de lectura a otra cuenta function registerUser(UserType userType, address user) public onlyOwner {if(userType == UserType.Basic){ basicUsers[user]= true;}elseif(userType == UserType.Personal){ personalUsers[user]= true;}} function getBasicInfo() public view authorizeUser(UserType.Basic)returns(BasicInfo memory){return basicInfo;} function getPersonalInfo() public view authorizeUser(UserType.Personal)returns(PersonalInfo memory){return personalInfo;}}
El contrato anterior, cumple con algunas pautas que permiten asegurar los datos de un usuario y que solo él pueda decidir qué hacer con estos.
Solo la dirección que crea la instancia del contrato tiene permisos de owner.
Solo el owner puede otorgar permisos a otras cuentas para que vean su información.
Otras cuentas pueden ver la información del owner, solo si este lo permitió previamente.
Consejos de seguridad para smart contracts
Guardar datos sensibles en un contrato inteligente requiere de un paso extra: encriptación. Producir variables privadas no basta para que nadie pueda acceder a ellos y existen algunos hacks para lograr obtener datos de una variable privada.
Esto no necesariamente es un bug o un problema, ya que todo en Blockchain debe ser transparente. Nada puede ocultarse realmente. Es por esto que se requieren algoritmos de encriptación para asegurar esos datos privados y que solo el owner del contrato conozca la manera de desencriptar los mismos.
Desafíos de la Autorización
De aquí se desprenden al menos dos retos para ti. Por un lado, la Autenticación y Autorización deben trabajar juntos. Un usuario no debería tener permisos para nada si previamente no fue autenticado. ¿Cómo podrías relacionar ambos conceptos en un contrato inteligente?
Por otro lado, volviendo al tema de la privacidad de datos, es realmente un desafió que los datos sean privados y que solo sean leídos por cuentas autorizadas. No es una solución que las variables sean privadas, tampoco el envío de contraseñas porque toda información es pública en la transacción.
No olvidemos que el código de un contrato inteligente también es público, por lo tanto, no nos sirve crear un superalgoritmo de encriptación o utilizar uno ya existente, porque el mismo será visible.
Entonces, ¿Blockchain no sirve para guardar datos sensibles? Como ya hemos dicho, es todo un desafío técnico y, como desarrolladores de software, debemos encontrar los caminos, investigar y leer mucho al respecto.
Posibles soluciones son la encriptación/desencriptación de los datos fuera de la Blockchain para enviar y recibir los mismos ya encriptados. Comparación de hashes para verificar los datos o utilizando servicios off-chain como ChainLink.
El ecosistema de Ethereum sigue creciendo y las soluciones existen o existirán. Continuar aprendiendo al respecto nos hará como profesionales en Blockchain y contratos inteligentes poder encontrar las mismas o incluso proponerlas.
Los contratos inteligentes o smart contracts son cadenas de bloques que se ejecutan cuando se cierra un acuerdo que cumple con ciertas condiciones establecidas, entre dos o más partes, y no necesita de una entidad o un tercero para ser aprobado. La identidad digital de una persona o una empresa puede ser representada por uno o más contratos inteligentes.
Autenticación vs. Autorización
Autenticación y autorización son dos palabras similares que podemos confundir, pero que en realidad no son sinónimos ni guardan relación.
Autenticación: demostrar que soy, quien digo que soy, para acceder a un lugar.
Autorización: una vez que demuestre quien soy y puedo acceder, tengo que demostrar qué permisos o accesos tengo para acceder en determinado lugar.
La Autenticación nos identifica y la Autorización nos da los privilegio o no para llegar hasta determinado punto de un sistema o lugar.
Autenticación y Autorización en Blockchain
En una Blockchain, a través de la dirección de una wallet, podemos determinar quién es el que realiza la transacción, puesto que esta solo puede ser firmada con una clave privada de la cuenta. La criptografía es el poderoso mecanismo que permite asegurar la identidad de una cuenta y que nadie más pueda falsificarla.
Autenticación de usuarios
Podemos representar y validar la autenticación de un usuario de forma muy sencilla en un contrato inteligente.
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
contract Authentication {
mapping(address => bool) public users;
function authenticate() public {
users[msg.sender] = true;
}
}
Guardamos en un mapping una relación entre una dirección y un booleano. Si una cuenta se autenticó previamente, podremos comprobarlo.
Lo importante aquí es que solo el dueño de la cuenta pueda poner en true el booleano que le corresponde a su dirección llamando a la función authenticate().
Autorización de usuarios
La autorización siempre es algo más compleja. Requiere llevar un registro de qué puede y qué no puede hacer un usuario.
contract Identity {
struct BasicInfo {
string name;
string email;
}
struct PersonalInfo {
uint256 salary;
string _address;
}
enum UserType {
Basic,
Personal
}
error UserUnauthorized(address user, UserType userType);
// Variables para guardar información de la cuenta
BasicInfo private basicInfo;
PersonalInfo private personalInfo;
address private owner;
// Mapping para otorgar permisos de lectura a otras cuentas
mapping(address => bool) private basicUsers;
mapping(address => bool) private personalUsers;
constructor(string memory name, string memory email, uint256 salary, string memory _address) {
basicInfo = BasicInfo(name, email);
personalInfo = PersonalInfo(salary, _address);
owner = msg.sender;
}
// Verificador de Autorización del usuario
modifier authorizeUser(UserType userType) {
if (msg.sender == owner || personalUsers[msg.sender]) {
_;
} else if (userType == UserType.Basic && basicUsers[msg.sender]) {
_;
} else {
revert UserUnauthorized(msg.sender, userType);
}
}
// Solo el owner puede otorgar permisos a otras cuentas
modifier onlyOwner() {
require(msg.sender == owner, "Only owner can authorize users");
_;
}
// Otorgamos permisos de lectura a otra cuenta
function registerUser(UserType userType, address user) public onlyOwner {
if (userType == UserType.Basic) {
basicUsers[user] = true;
} else if (userType == UserType.Personal) {
personalUsers[user] = true;
}
}
function getBasicInfo() public view authorizeUser(UserType.Basic) returns (BasicInfo memory) {
return basicInfo;
}
function getPersonalInfo() public view authorizeUser(UserType.Personal) returns (PersonalInfo memory) {
return personalInfo;
}
}
El contrato anterior, cumple con algunas pautas que permiten asegurar los datos de un usuario y que solo él pueda decidir qué hacer con estos.
Solo la dirección que crea la instancia del contrato tiene permisos de owner.
Solo el owner puede otorgar permisos a otras cuentas para que vean su información.
Otras cuentas pueden ver la información del owner, solo si este lo permitió previamente.
Consejos de seguridad para smart contracts
Guardar datos sensibles en un contrato inteligente requiere de un paso extra: encriptación. Producir variables privadas no basta para que nadie pueda acceder a ellos y existen algunos hacks para lograr obtener datos de una variable privada.
Esto no necesariamente es un bug o un problema, ya que todo en Blockchain debe ser transparente. Nada puede ocultarse realmente. Es por esto que se requieren algoritmos de encriptación para asegurar esos datos privados y que solo el owner del contrato conozca la manera de desencriptar los mismos.
Desafíos de la Autorización
De aquí se desprenden al menos dos retos para ti. Por un lado, la Autenticación y Autorización deben trabajar juntos. Un usuario no debería tener permisos para nada si previamente no fue autenticado. ¿Cómo podrías relacionar ambos conceptos en un contrato inteligente?
Por otro lado, volviendo al tema de la privacidad de datos, es realmente un desafió que los datos sean privados y que solo sean leídos por cuentas autorizadas. No es una solución que las variables sean privadas, tampoco el envío de contraseñas porque toda información es pública en la transacción.
No olvidemos que el código de un contrato inteligente también es público, por lo tanto, no nos sirve crear un superalgoritmo de encriptación o utilizar uno ya existente, porque el mismo será visible.
Entonces, ¿Blockchain no sirve para guardar datos sensibles? Como ya hemos dicho, es todo un desafío técnico y, como desarrolladores de software, debemos encontrar los caminos, investigar y leer mucho al respecto.
Posibles soluciones son la encriptación/desencriptación de los datos fuera de la Blockchain para enviar y recibir los mismos ya encriptados. Comparación de hashes para verificar los datos o utilizando servicios off-chain como ChainLink.
El ecosistema de Ethereum sigue creciendo y las soluciones existen o existirán. Continuar aprendiendo al respecto nos hará como profesionales en Blockchain y contratos inteligentes poder encontrar las mismas o incluso proponerlas.
En la blockchain no es suficiente declarar los datos sensibles como variables privadas porque estas son almacenadas en el Storage del Smart Contract y quedan disponibles para cualquier usuario.
En el ejemplo de la clase, el Storage quedaría de la siguiente forma:
Luego, usando ethers.js podemos acceder a esos valores de la siguiente forma:
const { ethers } = require("ethers");
require("dotenv").config();
const URL_RPC = process.env.KOVAN_RPC;
const provider = new ethers.providers.JsonRpcProvider(URL_RPC);
const main = async () => {
// Dirección del smart contract desplegado en la testnet Kovan
const contract_address = "0x6B2503f6f65FDB8455929febD5E8b6d14d4C2f0b";
// Accediendo a algunas variables privadas del smart contract
const my_personal_address = await provider.getStorageAt(contract_address, 3);
const contract_owner = await provider.getStorageAt(contract_address, 4);
// Imprimimos en consola los valores obtenidos:
console.log(my_personal_address);
// 0x746573743132330000000000000000000000000000000000000000000000000e
// ... Al pasar este valor en un convertidor Hex->ASCII objetenemos: "test123",
// que es la dirección de vivienda dada al desplegar el contrato
console.log(contract_owner);
// 0x000000000000000000000000133703a1e90ea8f72cb142cff7def47b940d3ece
// .. Al extraer los últimos 20 bytes de información obtenemos:
// 0x133703a1e90ea8f72cb142cff7def47b940d3ece, que es la address del owner
};
main();
Finalmente podemos usar este conversor de hexadecimal a ascii o decimal (según sea el tipo de dato almacenado) para descifrarlos.
Por eso es necesario que cualquier dato sensible almacenado en la blockchain deba estar encriptado.
Toda la información en una Blockchain es pública de alguna u otra manera. No basta con que las variables sean privadas, pero tampoco sirve enviar un TokenId por parámetro, ya que toda información es pública en la transacción.
Es un verdadero reto lograr asegurar los datos. Tal vez es buena idea enviar los datos al contrato ya encriptados y guardar el secret y el algoritmo para desencriptar en algún lugar off-chain. Hacer una comparación de hashes para verificar si los datos son correctos. O tal vez servicios off-chain como ChainLink ya lo tengan resuelto.
Cualquiera sea el caso, requiere de horas de estudio encontrar la mejor manera para realmente asegurar datos privados en un contrato.
Para resolver el reto planteado al final de la clase lo que yo hice fue unir los dos contratos (no se aun no como llamar de un contrato a otro) Y luego modifique los modifiers en donde le agregue un and en las condiciones.
Como pueden notar simplemente se trato de agregarle al codigo un
&& users[msg.sender]
Sin embargo con esto cuando no se cumpla la condicion de autenticado, el error message de igual manera arrojara un " UserUnauthorized". Ante ello, como paso extra cree un error UserUnauthenticated
error UserUnauthenticated(address user);
Y asi mismo toca modificar el 'else' del modifier anterior, el codigo del modifier final seria el siguiente:
El curso no especifica un grado de seguridad en particular ni menciona el uso de IA. Se enfoca en cómo blockchain y los smart contracts pueden mejorar la seguridad en áreas como la identidad digital y la ciberseguridad.
A ver si entiendo, si esto se corriera en una Dapp solamente la dirección desde la wallet que despliegue el contrato la primera vez puede autorizar usuarios?
Podrías darme un ejemplo más claro de como podría servir este caso de uso en una Dapp
En la blockchain no es suficiente declarar los datos sensibles como variables privadas porque estas son almacenadas en el Storage del Smart Contract y quedan disponibles para cualquier usuario.
En el ejemplo de la clase, el Storage quedaría de la siguiente forma:
Luego, usando ethers.js podemos acceder a esos valores de la siguiente forma:
const{ ethers }=require("ethers");require("dotenv").config();constURL_RPC= process.env.KOVAN_RPC;const provider =newethers.providers.JsonRpcProvider(URL_RPC);constmain=async()=>{// Dirección del smart contract desplegado en la testnet Kovanconst contract_address ="0x6B2503f6f65FDB8455929febD5E8b6d14d4C2f0b";// Accediendo a algunas variables privadas del smart contractconst my_personal_address =await provider.getStorageAt(contract_address,3);const contract_owner =await provider.getStorageAt(contract_address,4);// Imprimimos en consola los valores obtenidos:console.log(my_personal_address);// 0x746573743132330000000000000000000000000000000000000000000000000e// ... Al pasar este valor en un convertidor Hex->ASCII objetenemos: "test123",// que es la dirección de vivienda dada al desplegar el contratoconsole.log(contract_owner);// 0x000000000000000000000000133703a1e90ea8f72cb142cff7def47b940d3ece// .. Al extraer los últimos 20 bytes de información obtenemos: // 0x133703a1e90ea8f72cb142cff7def47b940d3ece, que es la address del owner};main();
Finalmente podemos usar este conversor de hexadecimal a ascii o decimal (según sea el tipo de dato almacenado) para descifrarlos.
Por eso es necesario que cualquier dato sensible almacenado en la blockchain deba estar encriptado.
Gracias :)
Muy buen aporte. En esta clase se puede ver un ejemplo de cómo extraer el valor de una variable privada de Solidity. Muy práctica!
Toda la información en una Blockchain es pública de alguna u otra manera. No basta con que las variables sean privadas, pero tampoco sirve enviar un TokenId por parámetro, ya que toda información es pública en la transacción.
Es un verdadero reto lograr asegurar los datos. Tal vez es buena idea enviar los datos al contrato ya encriptados y guardar el secret y el algoritmo para desencriptar en algún lugar off-chain. Hacer una comparación de hashes para verificar si los datos son correctos. O tal vez servicios off-chain como ChainLink ya lo tengan resuelto.
Cualquiera sea el caso, requiere de horas de estudio encontrar la mejor manera para realmente asegurar datos privados en un contrato.
8 meses después... averiguaste cual es la mejor solución? Me intriga.
Se ha avanzado mucho con zero-knowledge, algoritmos criptográficos capaces de demostrar el contenido de algo o ser dueño de algo, sin revelar ese algo. Creo que podría ser el camino a la hora de guardar datos sensibles.
Pero es algo muy complejo realmente. En proyectos sencillos, optaría por enviar la información encriptada, y que la llave de encriptación y descencriptación sea la propia clave privada del usuario. Sería una buena solución, sin entrar en temas técnicamente más complicados.
Saludos!
Propongo mi solución:
Armé un modifier en el contrato Identity que llama al contrato Authentication para validar si una dirección está autenticada.
address authAddr =address(0x123456789); modifier verifyAuth(address addrToVerify){(bool success, bytes memory result)= authAddr.call{gas:5000}( abi.encodeWithSignature("users(address)", addrToVerify));require(success,"Fallo el llamado al otro contrato."); bool auth = abi.decode(result,(bool));require(auth,"El contrato no esta autenticado."); _;}
Podemos utilizarla en el constructor para verificar la dirección que llama al contrato
constructor()verifyAuth(msg.sender){// ...}
O en cualquier otro punto donde se requiera verificar si un usuario está autenticado primero.
Para resolver el reto planteado al final de la clase lo que yo hice fue unir los dos contratos (no se aun no como llamar de un contrato a otro) Y luego modifique los modifiers en donde le agregue un and en las condiciones.
Como pueden notar simplemente se trato de agregarle al codigo un
&& users[msg.sender]
Sin embargo con esto cuando no se cumpla la condicion de autenticado, el error message de igual manera arrojara un " UserUnauthorized". Ante ello, como paso extra cree un error UserUnauthenticated
error UserUnauthenticated(address user);
Y asi mismo toca modificar el 'else' del modifier anterior, el codigo del modifier final seria el siguiente:
El curso no especifica un grado de seguridad en particular ni menciona el uso de IA. Se enfoca en cómo blockchain y los smart contracts pueden mejorar la seguridad en áreas como la identidad digital y la ciberseguridad.
¿por que dentro del constructor, salary no esta declarada en memoria pero las demas variables si?
Porque no es necesario. Los valores uint por defecto van a memory
¿porqué solo usan etherum y no bitcoin u otras cryptomonedas para hacer estos smartcontracts?
No logro ver cual es el archivo con la solución del profesor, en los archivos adjuntos ninguno tiene un contrato con esas características
Hola oscar te comparto el repositorio con la solución propuesta
Hola Oscar te comparto el repositorio con la solución propuesta
A ver si entiendo, si esto se corriera en una Dapp solamente la dirección desde la wallet que despliegue el contrato la primera vez puede autorizar usuarios?
Podrías darme un ejemplo más claro de como podría servir este caso de uso en una Dapp
Así es imagina que quieres restringir qué usuarios pueden hacer uso de tu dapp, con este contrato podrías autorizarlos
Por convencion el nombre del smart contract debería ser el mismo del archivo o no es necesario? es decir, el nombre del smart contract Identity debería llamarse MyProfile...
La direccion de la wallet no se obtiene a partit de la llave publica o privada? En ese sentido, la llave publica no seria la direccion de la wallet correcto ?
la verdad lo solucione de la manera mas simple entendiendo que no se puede acceder a la informacion de un usuario sin estar autenticado lo que hice fue relacionar los contratos en el Identity con el address de Authentication. y en el primero creo un mofier que llame al auth para validar si esta auth
por ultimo queria hacer un valor de expiracion por el block timespam asi que cuando lo haga subo la actualizacion, no si se aqui o en un repo y linkeo para aca
Resuelvo el reto pero, ampliando el contract para que se puedan registrar varios usuario, cada usuario podría registrar sus propios contrato, para lo cual debería ser autenticado. Los contactos también deberían ser usuarios del aplicativo con lo cual podrán acceder a los datos de sus contactos según el nivel de privilegio que cada contacto le asignó.
// SPDX-License-Identifier: MITpragma solidity >=0.7.0;contract Identity{// Registration and authentication in the dApp struct BasicInfo{ string name; string email;} struct PrivateInfo{ uint salary; string homeAddress;}enumStateUser{Active,Inactive}enumPrivilege{Basic,//Medium,Advance} struct Contact{ uint contactId; string contactName; address contactAddress;Privilege conctactPrivilege;} struct User{ uint userId; string userName; address userAddress;StateUser userState;BasicInfo userBasicInfo;PrivateInfo userPrivateInfo;}mapping(string=>mapping(string=>Contact))public userContacts;mapping(string=>User)public users;//address registered users address[] registeredUsers;//To know users registered uint usersNum =1; event NewUser( string userName, address userAddress
);functionCreateUser(string memory _userName, string memory _email, string memory _homeAddress, uint _salary)public{User memory newUser =User({userId: usersNum,userName: _userName,userAddress: msg.sender,userState:StateUser.Active,userBasicInfo:BasicInfo({name: _userName,email: _email
}),userPrivateInfo:PrivateInfo({salary: _salary,homeAddress: _homeAddress
})}); users[_userName]= newUser; emit NewUser(_userName, msg.sender); usersNum ++; registeredUsers.push(msg.sender);}functionAuthentication(string memory _userName)public view returns(string memory message){if(users[_userName].userId!=0&& users[_userName].userAddress== msg.sender){return message ="User registered";}else{return message ="User don't registered";}}// Manages information about users// 1. Registre contactos by usersfunctionRegisterContacts(string memory userName, string memory newContactName, address addresNewContact,Privilege privilegeNewContact)public{require(users[userName].userAddress== msg.sender,"You aren't the owner of this account"); uint newContactId =0;if(userContacts[userName][newContactName].contactId!=0){ newContactId = userContacts[userName][newContactName].contactId; newContactId ++;}Contact memory newContac =Contact({contactId: newContactId,contactName: newContactName,contactAddress: addresNewContact,conctactPrivilege: privilegeNewContact
}); userContacts[userName][newContactName]= newContac;}// 2. Getting information about user from contactsfunctiongetBasciInfo(string memory userName, string memory contactName)public view returns(BasicInfo memory){require(users[contactName].userAddress== msg.sender,"You need to register user");require(userContacts[userName][contactName].contactAddress== msg.sender,"You aren't contact of this user");return users[userName].userBasicInfo;}functiongetPrivateInfo(string memory userName, string memory contactName)public view returns(PrivateInfo memory){require(users[contactName].userAddress== msg.sender,"You need to register user");require(userContacts[userName][contactName].contactAddress== msg.sender&& userContacts[userName][contactName].conctactPrivilege==Privilege.Advance,"You aren't contact of this user");return users[userName].userPrivateInfo;}}
La siguiente mejora a agregar será que el usuario también pueda registrar su propia información asignándole un nivel de privacidad determinada, vinculado a los niveles de privilegio que otorgará a sus contacto, además que el usuario pueda modificar los privilegios de sus contactos.
Propuesta de solucion:
La forma mas secilla que pense es heredar del contrato de autenticacion, donde autorizacion contiene toda la info de variables y funciones del padre (Autenticacion).
Una vez teniendo toda esa info, se genera un error adicional para los usuarios no autenticados y se genera un modifier que actue en las funciones donde se consultan los datos. El modifier validara si el address se encuentra autenticado. El orden de los modifiers los coloque primero validando que el usuario este logueado y luego si tiene permisos o no.
Otra opcion puede ser generando un new instance del contrato de authentication dentro del contrato de authorization en el constructor y persistiendolo como variable para poder usarlo en el resto del contrato de autorizacion.