Mensajes

Ya que MAFUS puso su solución muestro mi solución al problema, mi solución también controla que la dimensión ingresada sea una matriz cuadrada como puede verse en la imagen:

Código (c) [Seleccionar] Expandir

#include <stdio.h>

int main()
{
   int i, j, filas, columnas;

   do
   {
       printf("Ingrese la dimension de matriz: ");
       scanf("%i*%i", &filas, &columnas);
   } while (filas != columnas);

   for(i = 1; i <= filas; i++)
   {
       for(j = 1; j <= columnas; j++)
       {
           if ((i + j -1) == columnas)
               printf("** ");
           else
               printf("%02d ", j);
       }

       printf("\n");
   }

   return 0;
}


B#

¿Cómo afecta esto a los que no usamos TOR?

Supongo que si el nodo tiene mucho tráfico, el ancho de banda se vería limitado si descargás algún material del servidor ns2...


B#

[for]

Hola, logré arreglar lo de las columnas y ya me da las matrices de la dimensión que quiera. ¿Cómo implemento lo de la diagonal para que me de asteriscos(**)?

Bien, añadiste el for que te mencioné para las columnas ahora solo falta la condición ( if else ) que verifica si el elemento de la matriz pertenece a la diagonal principal, prestá mucha atención a la tabla de 5x5 que mostraste hace un momento, si te fijás bien hay una operación matemática elemental que se cumple si encaja justo en la posición de la tabla por filas y columnas y dicha operación equivale a la dimensión total de las filas o columnas ingresadas al principio, vale aclarar que a la operación matemática se le tiene que restar 1 porque el primer elemento de la matriz comienzan con el valor 01...


B#

[for]

Estoy muy seguro que en lo que estoy fallando son los for.

El código está casi completo, solamente te falta un for por columnas y una condición que verifique si está en la diagonal invertida...
Como medida adicional para evitar que la matriz no sea cuadrada podrías meter un do while extra al principio.

EDIT: Acabé de probarlo tu código con las recomendaciones de arriba y funciona correctamente



B#

[no quiero correrlos]

A priori se me ocurrio utilizar Wine para poder correr los malwares, la cosa es que obviamente no quiero correrlos si no depurarlos.

A mi forma de entender, estás preguntando si hay alguna manera de analizar binarios de Windows sin ejecutarlos, osea análisis estático. Si se puede con Ghidra

PD importante: Recuerdo que intente correr el instalador de VirtualBox (solo queria ver si funcionaria) en Wine y se colgo   Luego se cerro solo. Esto es lo que me hace dudar de que vaya a correr un malware (Algunos son algo picky con los recursos que utilizan).

PD2: Respuesta frecuente: "Haz una maquina virtual" Claro, pero me gusta depurarlos. No puedo depurarlos con maquinas virtuales (Que si... puedo usar el comando experimental virtualboxvm --startvm <maquina> --debug, pero no me vale en este caso porque no te imaginas lo engorroso que es). Solo quiero saber si puedo hacer esto especificamente en Linux

Si querés instalar Virtualbox en Debian/Ubuntu:

Código (bash) [Seleccionar] Expandir

sudo apt install virtualbox-qt

EDIT: Añado un enlace de guía para desarrolladores y depuración con Wine...


B#

[Elementary OS]

¿Que distribucion de Linux usas?

Ubuntu

¿Por que la usas?

Estabilidad más que nada. Además brinda un buen soporte de hardware...

¿Por que usas Linux?

Hosteo un mini servicio de Jellyfin para ver series y películas en el chromecast (TV), otras PCs o celular, se podría hacer lo mismo con Windows pero consume recursos innecesarios comparado con Ubuntu.

A mi me gusta Elementary OS porque es bella y trae de todo... es la novia ideal con un aire de Mac, aunque tenga que pagar por ella...

Se puede descargar gratuitamente si se pone cero dolares en el espacio personalizado...


B#

Me explicáis como instalar Ubuntu o Linux a través de rufusx los procesos a seguir, recibiré actualizaciones etc.

Yo ya te dí hace unos meses atrás un par de videos, te vuelvo a poner el enlace para que lo mirés de otra vez:

https://foro.elhacker.net/gnulinux/puedo_instalar_linux_por_encima_de_windows_10-t510808.0.html;msg2244865#msg2244865


B#

[BloodVM.cpp]

Buenas gente del foro, hice este código simple en un par de horas en C++ para 32 bits en Windows y lo quería compartir para que pueda servirle a alguién o quién quiera colaborar en este proyecto y podemos hacerlo completo...

La idea de virtualización de código es hacer complicado el análisis de ingeniería inversa de cualquier programa, creando una CPU imaginaria con sus propios conjunto de instrucciones y reemplazando el código original de assembler de la CPU real por la CPU imaginaria.

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include "BloodVM.h"

int __declspec(naked) __stdcall Sumar()
{
    __asm
    {
        call BloodVM_Init;

        //MOV_R_N => mov eax, 4;
        _emit 0x02; //OPCODE::MOV_R_N
        _emit 0x05; //EAX offset
        _emit 0x04; //number 4 bytes
        _emit 0x00;
        _emit 0x00;
        _emit 0x00;
        //ADD_R_N => add eax, 5;
        _emit 0x04; //OPCODE::ADD_R_N
        _emit 0x05; //EAX offset
        _emit 0x05; //number 4 bytes
        _emit 0x00;
        _emit 0x00;
        _emit 0x00;
        //ADD_R_R => add eax, eax;
        _emit 0x03; //OPCODE::ADD_R_R
        _emit 0x05; //EAX offset
        _emit 0x05; //EAX offset
        //QUIT => Exit VM
        _emit 0x00;

        call BloodVM_End;
        ret;
    }
}

int main()
{
    std::cout << "Suma virtualizada (4 + 5) + (4 + 5) = " << Sumar() << std::endl;
    std::cin.ignore();
}



El código de ejemplo tiene apenas 5 instrucciones pero se podría implementar más. Al verse en un desamblador la función virtualizada se vería algo como esto:



Lo cuál forzaría al que quiera ver como funciona realmente el programa a analizar toda la CPU imaginaria siendo usualmente una tarea bastante compleja. Se podría crear también un programa que detecte las llamadas del inicio y fin de la virtualización y reemplazar el código real por el imaginario pero esa es una tarea bastante compleja que llevaría mucho tiempo.

Dejo el resto del código por si a alguien le interesa:

BloodVM.cpp

Código (cpp) [Seleccionar] Expandir

#include "BloodVM.h"

BloodVM gBloodVM;

uint32_t __declspec(naked) __stdcall GetCaller()//uint32_t dwESP)
{
    //return *(uint32_t*)(dwESP+4);
    __asm
    {
        mov eax, [esp + 4];
        ret;
    }
}

void __declspec(naked) __stdcall BloodVM_Init()
{
    __asm
    {
        pushad;
        pop gBloodVM.EDI;
        pop gBloodVM.ESI;
        pop gBloodVM.EBP;
        pop gBloodVM.ESP;
        pop gBloodVM.EBX;
        pop gBloodVM.EDX;
        pop gBloodVM.ECX;
        pop gBloodVM.EAX;
       
        //push gBloodVM.ESP;
        call GetCaller;
        mov gBloodVM.EIP, eax;
        lea ecx, gBloodVM;
        call BloodVM::RunVirtualMachine;
        mov eax, gBloodVM.EIP;
        mov [esp], eax;
        ret;
    }
}

void __declspec(naked) __stdcall BloodVM_End()
{
    __asm
    {
        mov edi, gBloodVM.EDI;
        mov esi, gBloodVM.ESI;
        mov ebx, gBloodVM.EBX;
        mov edx, gBloodVM.EDX;
        mov ecx, gBloodVM.ECX;
        mov eax, gBloodVM.EAX;
        mov ebp, gBloodVM.EBP;
        mov esp, gBloodVM.ESP;
        ret;
    }
}

void BloodVM::RunVirtualMachine()
{
    do
    {
        this->currentOpcode = (uint8_t)(*((uint8_t*)this->EIP));
        uint32_t nextEIP = this->vInstructions[this->currentOpcode].sizeOfInstruction;
        (this->*vInstructions[this->currentOpcode].operate)();
        this->EIP += nextEIP;
    } while (this->currentOpcode != OPCODE::QUIT);
}

void BloodVM::QUIT()
{

}

void BloodVM::MOV()
{
    uint32_t* firstRegister;
    uint32_t* secondRegister;
    uint32_t firstNumber;
    switch (this->currentOpcode)
    {
        case OPCODE::MOV_R_R:
            firstRegister = &this->EDI + *(uint8_t*)(this->EIP + 1);
            secondRegister = &this->EDI + *(uint8_t*)(this->EIP + 2);
            *firstRegister = *secondRegister;
            break;
        case OPCODE::MOV_R_N:
            firstRegister = &this->EDI + *(uint8_t*)(this->EIP + 1);
            firstNumber = *(uint32_t*)(this->EIP + 2);
            *firstRegister = firstNumber;
            break;
    }
}

void BloodVM::ADD()
{
    uint32_t* firstRegister;
    uint32_t* secondRegister;
    uint32_t firstNumber;
    switch (this->currentOpcode)
    {
        case OPCODE::ADD_R_R:
            firstRegister = &this->EDI + *(uint8_t*)(this->EIP + 1);
            secondRegister = &this->EDI + *(uint8_t*)(this->EIP + 2);
            *firstRegister += *secondRegister;
            break;
        case OPCODE::ADD_R_N:
            firstRegister = &this->EDI + *(uint8_t*)(this->EIP + 1);
            firstNumber = *(uint32_t*)(this->EIP + 2);
            *firstRegister += firstNumber;
            break;
    }
}

BloodVM.h

Código (cpp) [Seleccionar] Expandir

#pragma once
#include <cstdint>
#include <vector>

enum OPCODE
{
QUIT,
MOV_R_R,
MOV_R_N,
ADD_R_R,
ADD_R_N,
};

class BloodVM
{
public:
BloodVM()
{
vInstructions =
{
/*
All opcodes sizes are always 1 byte
All registers (R) sizes are also 1 byte
All numbers (N) sizes are always 4 bytes
*/
{OPCODE::QUIT, 1, &BloodVM::QUIT},
{OPCODE::MOV_R_R, 3, &BloodVM::MOV},
{OPCODE::MOV_R_N, 6, &BloodVM::MOV},
{OPCODE::ADD_R_R, 3, &BloodVM::ADD},
{OPCODE::ADD_R_N, 6, &BloodVM::ADD},
};
}
        uint32_t EDI, ESI, EBX, EDX, ECX, EAX, EBP, EIP, ESP;
uint8_t currentOpcode;
void RunVirtualMachine();

void MOV();
void ADD();
void QUIT();

struct INSTRUCTION
{
uint8_t opcode;
uint8_t sizeOfInstruction;
void (BloodVM::* operate)() = nullptr;
};

std::vector<INSTRUCTION> vInstructions;
};

void __stdcall BloodVM_Init();
void __stdcall BloodVM_End();


B#

Básicamente solo quiero saber si utiliza un pc o un celular...

Se conecta pero, ¿A que lugar te referís? ¿Un servidor web? ¿Un modem/router? ¿Cuál es el dispositivo de destino al cuál te estás preguntando?


B#

Los hecho de menos DONDE ESTAN? 
Han mudado de foro? que pasoooó?

Ahora se dicen llamar Terradonistas algunos... 




B#