martes, 19 de agosto de 2008

Kernel Simple

h0aX [hoax_ws@yahoo.es]

En la edición 43 de este boletín se publicó un código titulado "Mulo-BootLoader" donde se presentaba un boot loader en su estado más simple. Siguiendo la misma praxis probablemente deba nombrar este código "Kernel a lo bestia" o algo parecido, pero por respeto a las bestias me limitaré a llamarlo "Kernel Simple".

Esta vez en nuestro taller de códigos presentaré el primer kernel publicado en BlackHat, tan cubano como inacabado pero muy útil para aquellos que deseen orientación en la utilización de las interrupciones del BIOS como primera línea de fuego en el acceso al hardware de nuestras PCs.

Aclaro que el código va dedicado solo a programadores experimentados en C, con sólidas bases de ensamblador y arquitectura de máquinas 8086. Por falta de tiempo no podría entregarme al placer de escribir un manual del tipo -Comenzando el desarrollo de un kernel-, no obstante estoy dispuesto a compartir gustosamente mi bibliografía con aquellas personas que me hagan saber su interés.

Por último sería injusto dejar de mencionar el sistema ADIX OS de Aditya Kumar Singh como mi principal referencia para este experimento.

[Instalando el kernel en un floppy]
Al final de este artículo encontrarás disponible para su descarga el archivo Calipso.zip. A continuación se describen los pasos a seguir para instalar su contenido.

1 Con una consola del sistema posiciónate en el directorio BOOT
2 Introduce un diskette formateado en la disquetera
3 Ejecuta el siguiente comando en el símbolo del sistema "PC boot12.bin 0 3 –f0" (sin comillas)
4 Ejecuta el siguiente comando en el símbolo del sistema "PC boot12.bin 3e 1c2 –f0 3e"
5 Por último copiamos el kernel al diskette con el comando "COPY ..\Kernel\kernel.bin a:"

Nota: PC.exe es un programa llamado Partial Copy cuya funcionalidad consiste en el copiado de datos raw a disco, de este modo escribimos el bootloader en el sector de arranque inicial del disquette.

Para probar el sistema reinicia el PC con el diskette.

Archivos relacionados

Calipso.zip

Continuar leyendo

Respuesta al Ejercicio BH 63

Eddy [delvalle@otepr.co.cu]

Enunciado:

Hay M soldados en un cerco y tienen un solo caballo. Para salir forman circularmente y comienzan a contar inicialmente por un soldado elegido al azar. Cada N soldados uno sale y el último se queda con el caballo.
Hacer un programa que permita imprimir que soldado saldrá del cerco eon el caballo si se conoce la cantidad de soldados (M) y el incremento (N) en el conteo.

#!/usr/bin/env python
cant_soldados = int(raw_input("Entre la cantidad soldados: "))
iteraciones = int(raw_input("Entre el numero escogido: "))

soldados = range(1, cant_soldados+1)

i = 0
n = 1
while len(soldados) > 1:
if i == len(soldados):
i = 0
if n == iteraciones:
del soldados[i]
n = 1
else:
n = n + 1
i = i + 1

print soldados[0]

Continuar leyendo

Ejercicio BH 64

Confeccione un programa para imprimir todos los números pares de 4 cifras formados por los d¡gitos 0,1,2,3 que cumplan la condición de que los d¡gitos que lo forman no se repitan.

Continuar leyendo

Extraer elementos de tipo específico de una lista

Eddy [delvalle@otepr.co.cu]

Esta es una función a la que se le pasa como parámetro un tipo y una colección, y ella devuelve sólo los elementos que son del tipo que se le pasó como parámetro, este puede ser, por su puesto, una clase definina por ti.
La sección de código bajo la definición de la función es para probar la función con un ejemplo.

#!/usr/bin/env python
def extraerPorTipo(tipo, coleccion):
lista = []
for elemento in coleccion:
if isinstance(elemento, tipo):
lista.append(elemento)
return lista

#esta seccion hace la comprobacion de la función
cadena = "esta es una cadena"
milista = ["asd", 3, "hola", 5.0, 4, cadena]
print "de la lista "+str(milista)+" son de tipo entero:"
print extraerPorTipo(int, milista)
raw_input("presione enter para continuar")

#esto devolvera:
# de la lista ['asd', 3, 'hola', 5.0, 4, 'esta es una cadena'] son de tipo entero:
# [3, 4]

Continuar leyendo

Lupa

CHenry [chenry@lab.matcom.uh.cu]

Windows tiene un programa que hace algo similar, no obstante, nunca está demás ver una réplica de dicha utilidad, más cuando esta ha sido creada por un cubano, miembro de BlackHat y muchísimo más si pone a disposición de todos el código fuente.

/* Escrito por chenry para la comunidad de BH
Compilado con VS2003
*/
#include "stdafx.h"
#include "lupa.h"
#define MAX_LOADSTRING 100

HINSTANCE hInst;
TCHAR szTitle[MAX_LOADSTRING] = "Lupa by chenry for BH";
TCHAR szWindowClass[MAX_LOADSTRING] = "lupa";

ATOM MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY _tWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow)
{
  MSG msg;
  HACCEL hAccelTable;

   MyRegisterClass(hInstance);

  if (!InitInstance (hInstance, nCmdShow))
  {
    return FALSE;
  }

  hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_LUPA);

  while (GetMessage(&msg, NULL, 0, 0))
  {
    if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
    {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }
  }

  return (int) msg.wParam;
}

ATOM MyRegisterClass(HINSTANCE hInstance)
{
  WNDCLASSEX wcex;

  wcex.cbSize = sizeof(WNDCLASSEX);

  wcex.style = CS_HREDRAW | CS_VREDRAW;
  wcex.lpfnWndProc = (WNDPROC)WndProc;
  wcex.cbClsExtra = 0;
  wcex.cbWndExtra = 0;
  wcex.hInstance = hInstance;
  wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_LUPA);
  wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
  wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
  wcex.lpszMenuName = (LPCTSTR)IDC_LUPA;
  wcex.lpszClassName = szWindowClass;
  wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);

  return RegisterClassEx(&wcex);
}

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
  HWND hWnd;

  hInst = hInstance; // Store instance handle in our global variable

  hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW | WS_VSCROLL,
50,50,200,200, NULL, NULL, hInstance, NULL);

  if (!hWnd)
  {
    return FALSE;
  }

  ShowWindow(hWnd, nCmdShow);
  UpdateWindow(hWnd);

  return TRUE;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
  int wmId, wmEvent;
  PAINTSTRUCT ps;

  HDC hdc,hdcDesktop;
  static RECT paintRect;

  RECT clientRect;
  POINT punto;

  static bool isPainting;
  SCROLLINFO scroll;

  static int zoom;
  static bool onTimer=false;

  switch (message)
  {
    case WM_VSCROLL:
    {
      GetClientRect(hWnd,&clientRect);
      switch (LOWORD(wParam))
      {
        case SB_LINEUP:
        {
          if(zoom>1&&zoom<6)
          {
            zoom = zoom - 1;
            SetScrollPos(hWnd,SB_VERT,(zoom -1) * clientRect.bottom/5,TRUE);
          }
          return 0;
        }
        case SB_LINEDOWN:
        {
          if(zoom>0&&zoom<5)
          {
            zoom = zoom + 1;
            SetScrollPos(hWnd,SB_VERT,(zoom -1) * clientRect.bottom/5,TRUE);
          }
          return 0;
        }
      }

      return 0;
    }
    case WM_SIZE:
    {
      GetClientRect(hWnd,&clientRect);
      scroll.cbSize = sizeof(SCROLLINFO);
      scroll.fMask = SIF_ALL;
      scroll.nMin = 0;
      scroll.nMax = clientRect.bottom;
      scroll.nPage = clientRect.bottom/5;
      scroll.nPos = (zoom -1) * clientRect.bottom/5;
      SetScrollInfo(hWnd,SB_VERT,&scroll,TRUE);
      return 0;
    }
    case WM_LBUTTONDOWN:
    {
      hdcDesktop = GetDC(NULL);
      SetROP2(hdcDesktop, R2_NOT);

      Rectangle(hdcDesktop,paintRect.left,paintRect.top,paintRect.right,paintRect.bottom);
      DeleteDC(hdcDesktop);

      SetCapture(hWnd);
      isPainting = true;
      onTimer=false;

      return 0;
    }
    case WM_LBUTTONUP:
    {
      hdcDesktop = GetDC(NULL);
      SetROP2(hdcDesktop, R2_NOT);
      Rectangle(hdcDesktop,paintRect.left,paintRect.top,paintRect.right,paintRect.bottom);
      DeleteDC(hdcDesktop);

      InvalidateRect(hWnd,NULL,true);

      ReleaseCapture();
      isPainting = false;
      onTimer=true;

      return 0;
    }

    case WM_MOUSEMOVE:
    {
      if(isPainting)
      {
        GetCursorPos(&punto);

        hdcDesktop = GetDC(NULL);
        SetROP2(hdcDesktop, R2_NOT);
        Rectangle(hdcDesktop,paintRect.left,paintRect.top,paintRect.right,paintRect.bottom);
        DeleteDC(hdcDesktop);

        GetClientRect(hWnd,&clientRect);

        paintRect.left = punto.x - (clientRect.right - clientRect.left)/(2*zoom);
        paintRect.right = punto.x + (clientRect.right - clientRect.left)/(2*zoom);
        paintRect.top = punto.y - (clientRect.bottom - clientRect.top)/(2*zoom);
        paintRect.bottom = punto.y + (clientRect.bottom - clientRect.top)/(2*zoom);

        hdcDesktop = GetDC(NULL);
        SetROP2(hdcDesktop, R2_NOT);

        Rectangle(hdcDesktop,paintRect.left,paintRect.top,paintRect.right,paintRect.bottom);
        DeleteDC(hdcDesktop);

        InvalidateRect(hWnd,NULL,true);
      }
      return 0;
    }
    case WM_CREATE:
    {
      zoom = 5;
      GetClientRect(hWnd,&clientRect);
      scroll.cbSize = sizeof(SCROLLINFO);
      scroll.fMask = SIF_ALL;
      scroll.nMin = 0;
      scroll.nMax = clientRect.bottom;
      scroll.nPage = clientRect.bottom/5;
      scroll.nPos = (zoom -1) * clientRect.bottom/5;;
      SetScrollInfo(hWnd,SB_VERT,&scroll,TRUE);

      isPainting = false;
      SetWindowPos(hWnd,HWND_TOPMOST,0,0,0,0,SWP_NOMOVE | SWP_NOSIZE);
      SetTimer(hWnd,1,100,NULL);
      return 0;
    }
    case WM_TIMER:
    {
      if(onTimer)
      {
        hdc = GetDC(hWnd);

        hdcDesktop = GetDC(NULL);
        GetClientRect(hWnd,&clientRect);
        if(isPainting)
        StretchBlt(hdc,clientRect.left,clientRect.top,(clientRect.right - clientRect.left),(clientRect.bottom - clientRect.top),hdcDesktop,paintRect.left,paintRect.top,(paintRect.right - paintRect.left),(paintRect.bottom - paintRect.top),SRCINVERT);
        else
StretchBlt(hdc,clientRect.left,clientRect.top,(clientRect.right - clientRect.left),(clientRect.bottom - clientRect.top),hdcDesktop,paintRect.left,paintRect.top,(paintRect.right - paintRect.left),(paintRect.bottom - paintRect.top),SRCCOPY);

        DeleteDC(hdcDesktop);

        ReleaseDC(hWnd,hdc);

      }
      return 0;
    }
    case WM_COMMAND:
    {
      wmId = LOWORD(wParam);
      wmEvent = HIWORD(wParam);

// Parse the menu selections:
      switch (wmId)
      {
        case IDM_EXIT:
        DestroyWindow(hWnd);
        return 0;
        default:
        return DefWindowProc(hWnd, message, wParam, lParam);
      }
      return 0;
    }
    case WM_PAINT:
    {
      hdc = BeginPaint(hWnd, &ps);

      hdcDesktop = GetDC(NULL);
      GetClientRect(hWnd,&clientRect);
      if(isPainting)
      StretchBlt(hdc,clientRect.left,clientRect.top,(clientRect.right - clientRect.left),(clientRect.bottom - clientRect.top),hdcDesktop,paintRect.left,paintRect.top,(paintRect.right - paintRect.left),(paintRect.bottom - paintRect.top),SRCINVERT);
      else
      StretchBlt(hdc,clientRect.left,clientRect.top,(clientRect.right - clientRect.left),(clientRect.bottom - clientRect.top),hdcDesktop,paintRect.left,paintRect.top,(paintRect.right - paintRect.left),(paintRect.bottom - paintRect.top),SRCCOPY);

      DeleteDC(hdcDesktop);

      EndPaint(hWnd, &ps);
      return 0;
    }
    case WM_DESTROY:
    {
      PostQuitMessage(0);
      return 0;
    }
    default:
    return DefWindowProc(hWnd, message, wParam, lParam);
  }
  return 0;
}

void DrawBoxOutline (HWND hwnd, RECT rect)
{
  HDC hdc ;
  hdc = GetDC (NULL) ;
  SetROP2 (hdc, R2_NOT) ;
  SelectObject (hdc, GetStockObject (NULL_BRUSH)) ;
  Rectangle (hdc, rect.left, rect.top, rect.right, rect.bottom) ;
  ReleaseDC (hwnd, hdc) ;
}

Archivos relacionados

Lupa.zip

Continuar leyendo

lunes, 11 de agosto de 2008

Respuesta al Ejercicio BH 59

thunder [yuniet02015@hab.jovenclub.cu]

Ejercicio:
==========
Los números 46 y 96 tienen una curiosa propiedad, su producto no se altera aunque las cifras que lo integran cambien de lugar.
46 * 96 = 4416
64 * 69 = 4416
Confeccione un programa para imprimir todos los números de dos cifras que cumplen esta propiedad.



'=========================================
'= Respuesta en Visual Basic =
'= al pequeño ejercicio =
'= de la edicion #59 =
'= de la revista =
'= BlackHat =
'=========================================

Private Sub Command1_Click()
  On Error Resume Next

  For a = 9 To 98
    num1 = a + 1
    rev1 = StrReverse(num1)
    For i = 9 To 98
      num2 = i + 1
      result1 = num1 * num2
      rev2 = StrReverse(num2)
      result2 = rev1 * rev2

      If result1 = result2 Then
        Text1.Text = Text1.Text + Str(num1) + " -" + Str(num2) + vbCrLf
        c = c + 1
        Label2.Caption = c
      End If

    Next
  Next

End Sub

Private Sub Command2_Click()
  Text1.Text = ""
  Label2.Caption = ""
  Command1.SetFocus
End Sub

Archivos relacionados

Respuesta.zip

Continuar leyendo

Cut File

Alien [blackhat4all@gmail.com]

Este código no es ni será catalogado como la gran invención del año, pero si puede ser de utilidad para muchos que quieran meter en un dispositivo de poca capacidad un archivo de audio o video que supera el tamaño de la unidad en la que se quiere introducir.

CLS
'Definimos el buffer, que no es más que la cantidad de bites que serán leídos en cada pasada.
'Mientras mayor sea el buffer más rápido terminará
DIM buffer AS STRING * 32000
OPEN ("k:\nuevo\a.dat") FOR BINARY AS #1
  OPEN ("c:\b.dat") FOR BINARY AS #2

'Hacemos un ciclo hasta la cantidad de Megas que queremos copiar (en este caso son 490 Mb)
    FOR i = 1 TO 490 * 1048576 STEP 32000
      GET #1, i, buffer
      PUT #2, i, buffer

'Nos paramos en la primera línea y mostramos el progreso...
      LOCATE 1, 1
      PRINT "Guardando: "; INT(i / 1048576); " Mb"
    NEXT
  CLOSE #2
CLOSE #1


Sabiendo de antemano que un archivo de audio o video puede funcionar aún faltandole parte de este, este código lo que hace en sí es definir un tamaño (siempre menor que el del archivo) y empezar a copiar hasta que se llegue a ese tamaño. En este caso el tamaño definido es de 490 Mb. Al terminar, se tendrá solo la primera parte del archivo hasta que este llegue al tamaño especificado.

Si se sabe el tamaño de la cabecera del archivo, se pudiera hacer un programa que, en lugar de solo llevar a parte los primeros x Mb del archivo, divida al mismo en varios pedazos, pero bueno, eso será en otra edición xD.

Continuar leyendo