Seguridad, Capítulo 1.- ¡Mama! ¡Mama! mira lo que hago...

De doc.ubuntu-es
(Diferencia entre las páginas)
Saltar a: navegación, buscar
(categorizo)
Línea 1: Línea 1:
== Introducción a la seguridad en Linux ==
+
== Introducción ==
 +
Este capítulo esta exento de contenidos que puedan servir de mucho para aprender, pero es necesario para poder seguir adelante, por eso el título del capítulo, porque realmente haremos cosas, pero no diremos porque las hacemos, simplemente asumiremos que es necesario hacerlas para poder empezar una aplicación con [http://www.wxwidgets.org/ wxWidgets].
  
:Últimamente hablamos mucho sobre seguridad en todos los ámbitos de la vida. Los ordenadores no están excluidos y se han escritos páginas y páginas sobre la seguridad, pero bastante poco acerca de lo que queremos asegurar y cuál es el costo, en dinero y trabajo, de la relación seguridad-necesidad o conveniencia.
+
== Construcción del programa 0 ==
<p>
+
Bueno, vamos a ver si conseguimos crear nuestro programa cero...
  
:El entorno sobre el que opera un ordenador no difiere mucho del entorno de nuestra casa, la oficina, una empresa, una gran empresa o simplemente el Estado.<br>
+
Este va a ser nuestro paso fundamental, de donde empezaremos a crear, supongo que estas familiarizado con el tema de las clases en C++, aun asi iremos poquito a poco...
  
:Cada uno de estos ámbitos tiene una relación formada por el valor de lo que queremos asegurar con las medidas que adoptamos para llevar a cabo esa seguridad. La seguridad cuesta trabajo y dinero y si bien en nuestro ámbito personal, o sea, el ordenador que tenemos en nuestra casa, podemos establecer unas normas y unas barreras con un poco de trabajo y nada de dinero, no está de más tener en cuenta, cuáles son las '''necesidades reales''' de protección.<br>
+
Bien, parece que lo primero será arrancar nuestro Code::Blocks
 +
<ul>
 +
<li>
 +
Por terminal, escribiendo lo siguiente:
 +
<pre>
 +
codeblocks %F
 +
</pre>
 +
</li>
 +
<li>
 +
O por los menús:
 +
<pre>
 +
Aplicaciones/Programacion/Code::blocks
 +
</pre>
 +
</li>
 +
</ul>
  
:Está claro que cuanto más valiosos son los datos y la operabilidad de un sistema informático, como puede serlo un banco o el servicio de controladores de vuelo de un aeropuerto, más sofisticado y caro será el sistema de protección de aquel equipo, pero la necesidad de estos equipos dista mucho de aquel equipo que tenemos instalado en nuestra casa.<br>
+
Nada mas arrancar nos da algún consejito, y despues nos invita amablemente a crear un proyecto, asi que dale al dibujito, o vete a:
 +
<pre>
 +
file/new.../project...
 +
</pre>
  
:Todo esto sucede, en gran parte, porque hasta la fecha no existe ningún ordenador/sistema 100% seguro, salvo que esté suspendido en el espacio y dentro de una «Caja de Faraday», sin ningún tipo de conexión exterior, claro.<br>
+
Se que la emocion te embarga...¿pero qué es eso? ¿un wxwidgets project? ¡¡¡Pues cojámoslo!!!
:Pero como esto no es la realidad, aceptamos que por sofisticado que sea un sistema, siempre tendrá alguna vulnerabilidad, ocasionada por la necesidad de tener que acceder al mismo desde fuera.<br>
+
  
:Pero, vamos a lo práctico.
+
Luego de dar un par de "siguientes" escoge un wxWidgets2.8.x (suponiendo que esa fue la versión que instalaste en el capítulo anterior)
{|class="wikitable" cellpading="8" align="right"
+
|-
+
|
+
|
+
|
+
|
+
|
+
|}
+
{|class="wikitable" Boder="1" style="background:#5d9a76; border:1px solid" cellpadding="8" cellspacing="0" align="right" width="150"
+
!''ATENCION''
+
|-style="background:#eee"
+
|''El admistrador del sistema tiene acceso a todos los recursos.<br> Si un administrador no es consciente de lo anterior, posiblemente sea él mismo el que tire abajo el sistema sin necesidad de ningún tipo de ayuda externa''.
+
|}
+
  
:Empezaremos por lo más sencillo, el ordenador de casa. Como esta es una página de documentación de Ubuntu, por lo tanto un sistema GNU/Linux, aplicando lo expuesto más arriba, asumimos que nuestro equipo necesita protección. GNU/Linux no es por lo tanto un sistema 100% seguro, en gran medida porque fue diseñado para compartir o sea operar en redes de manera flexible.<br>
+
Continuamos hasta la pantalla en la que tengamos que darle un nombre al proyecto. Yo, por limpieza (y porque he probado 100000 IDE's), decidí almacenar estos proyectos en una subcarpeta llamada "proyectos_codeblocks"
:Y esta flexibilidad es en sí misma su debilidad. No hablaremos aquí del mundo de Windows, dado que allí las vulnerabilidades son aun mucho mayores, además de ser mejor blanco de ataques, dada su implantación masiva. Nuestro sistema necesita atención y sobre todo, tener muy claro qué función estará destinado a ofrecer.<br>
+
  
:Lo primero que nos pasa por la cabeza cuando hablamos de seguridad, son los virus. Esta paranoia la heredamos de Windows por la enorme cantidad de código malicioso que se ha desarrollado para este sistema operativo y, de la misma manera que no encendemos un mechero cerca de un surtidor de gasolina, tampoco conectamos un equipo con Windows a la red sin un poderoso antivirus.<br>
+
Asi pues, vete a tu directorio personal, y crea una carpeta con ese nombre, luego vuelve a codeblocks y mete estos datos:
 +
Project title: <b>learn_0.01</b>
 +
Folder to create project in: <b>/home/<u>user</u>/proyectos_codeblocks/</b>
 +
<u>(donde user sera tu usuario)</u>
 +
Project file name: <b><u>Te lo rellenara el</u></b>
 +
Resulting filename: <b><u>Te lo rellenara el</u></b>
  
:Afortunadamente en GNU/Linux, este problema prácticamente no existe. Hay muy pocos virus conocidos para Linux y por otra parte digamos que es mas difícil que se instalen en nuestro equipo sin nuestro consentimiento, gracias a la arquitectura del propio sistema operativo, que mantiene un orden de jerarquía férreo sobre las posibilidades de inclusión de nuevo software en nuestra máquina.<br>
+
&lt;&lt;Breve explicación: con esto Code::Blocks te creará la siguiente carpeta: /home/<b>user</b>/proyectos_codeblocks/learn_0.01/, y dentro de esa carpeta, te creará este archivo: learn_0.01.cbp. Bien, cuando quiera retomar tu proyecto, ese será el archivo que deberás abrir&gt;&gt;
  
:''Pero existen otras amenazas que no son sólo virus.''<br>
+
Y dale a "next", mete tu nombre y demás datos, y vuelvele a dar a "next", apareciendo la pantalla del Designer... Nosotros no queremos Designer, pues aunque en un principio parece facilitar las cosas, mentira, solo las complica, nosotros vamos a aprender de verdad... Así que elige "None", y "Dialog Based", y dale a "next".
  
:'''Por contradictorio que parezca, quien más daño causa a nuestros datos y a nuestro sistema, somos nosotros mismos, o sea, tenemos que PROTEGER lo que consideramos valioso, de nosotros mismos, y para eso sólo bastan unas simples normas, un trabajo ordenado y sistemático.'''<br>
+
Ahora te aparecerá la pantalla del los compiladores, que esta bien como esta (asumo que te sale el compilador gcc), asi que dale a "next"...
  
===Primeras medidas===
+
&lt;&lt;Breve explicación: ahora ya esta preparado, tu proyecto se sitúa en /home/<b>user</b>/proyectos_codeblocks/learn_0.01/, y allí es donde deben estar tus *.cpp, y tus *.h. Respecto a los compilados, las versiones release (mas rapidas, pero no permiten debugar) estarán en la subcarpeta bin/Release, y las debug en bin/Debug&gt;&gt;
  
 +
La última pantalla se refiere al proyecto inicial, nosotros somos unos valientes, asi que le daremos a "Use default..." y a "create empty project"
  
 +
Bueno, si ves el Code::Blocks, a la izquierda tienes un árbol con tu workspace, pero esta vacío (tal y como le pedimos, porque vamos a aprender ¿no? :-D ). Así que no cabe duda, necesitamos un main, por tanto vamos a ello...
  
:La primera medida debemos tomarla desde el momento en que instalamos un sistema operativo en nuestra máquina.
+
Pincha encima de learn_0.01 en el árbol, y vete a:
 +
<pre>
 +
file/new.../file...
 +
</pre>
 +
Y escoge "C/C++ Source", dale a "next" hasta que llegues a la pantalla de darle nombre... Code::blocks en esto esta quizás mal programado, y si le das directamente el nombre, te dirá que no es un directorio válido, así que dale al botoncito que tiene justo a la derecha del campo de texto, y escribe el nombre "main.cpp", y acepta, asi el ya te escribirá la ruta entera. Marca Debug y Release, y Acepta...
  
{|class="wikitable" border="0" cellspacing="4" cellpadding="4" width="900" style="background:#f7f2ed" aling="center"
+
Y se te abre el solito... Podras encontrarlo tambien en el arbol expandiendo "learn_0.01->sources->main.cpp"
|-
+
|''1)--''
+
|Asegurarnos que la distribución y la versión de ésta sea soportada por el hardware del cual disponemos. Puede ocurrir que logremos instalar una versión que tenga requerimientos de hardware mayores de los que disponemos, pero nos estamos arriesgando a que un día, el sistema sufra un colapso del que no sepamos salir y que la única opción a nuestro alcance sea formatear, con lo que perderíamos todo el contenido.
+
|-
+
|''2)--''
+
|Al particionar el disco duro, tener en cuenta la posibilidad de asignar particiones diferentes asignando al sistema una propia (representada por «/») y otra para /home, con lo cual, en caso de tener que formatear, sólo lo haríamos en aquella donde está el sistema, salvaguardando nuestros archivos. Evidentemente pueden crearse más particiones para alojar otros archivos especiales.
+
|-
+
|''3)--''
+
|A partir de aquí, según la necesidad de mantener un estricto control sobre nuestra máquina, es decir, evitar que alguna persona pueda arrancar nuestro equipo, salvo nosotros claro, será necesario configurar el gestor de arranque, grub por lo general, a través de una contraseña que incluso puede estar cifrada. Esto se hace con «grub-md5-crypt» o con la función «lock» según intereses, pero se explicará la configuración mas adelante.
+
|-
+
|''4)--''
+
|Una vez tenemos el sistema operativo en marcha, Ubuntu «protege» de desastres, no activando de manera predeterminada la cuenta ''root'' aunque nos proporciona el comando «[[sudo]]» que nos permite tomar prestadas momentáneamente sus atribuciones como amo y señor del sistema, por lo que no debe de activarse esta cuenta a no ser que sea estrictamente necesario.
+
|-
+
|'' 5)--''
+
|El control físico de la máquina, tiene más importancia de lo que parece. De qué nos sirve tener toda una batería de medidas de defensa evitando la intrusión vía red, si nos levantamos de la silla y dejamos el [[terminal]] abierto con lo que en menos de un minuto podrían hacernos un estropicio tan grande en el sistema que sería insalvable. Esto es poco probable en un entorno doméstico, pero....
+
Para evitar disgustos podemos bloquear a través del teclado, la pantalla. Para ello usamos:
+
'''Sistema --> Preferencias --> Combinaciones de teclas'''. Buscamos «bloquear pantalla» que por defecto es: <Ctrl-Alt-L> y la cambiamos por la que nos guste
+
|-
+
|''6)--''
+
| Elegir una contraseña que cumpla las expectativas propias de una contraseña: que sea difícil de averiguar. Es decir, no poner ninguna palabra que aparezca en un diccionario, fechas, nombres de mascotas o nombres propios en general. Por el contrario debemos «crear» una contraseña que contenga números, algunas mayúsculas, combinaciones de sílabas de varias palabras, en fin, hay que poner a trabajar la imaginación. Prácticamente todas las contraseñas son descifrables, pero podemos hacer que haya que tomarse su tiempo, y eso desalienta a muchos intrusos.
+
|-
+
|''7)--''
+
| No guardaremos en el ordenador ningún dato que usados por terceras personas puedan causarnos un gran trastorno, por ejemplo, las contraseñas de nuestras tarjetas de crédito, claves bancarias y cosas por el estilo, seguro que nos ahorraremos muchos disgustos.
+
Hay que pensar que, una vez que estamos conectados a la red, nuestro ordenador es como nuestra casa, está aislada del resto de nuestros vecinos por su entorno físico, pero tiene puerta, para que podamos entrar e incluso para permitir el acceso de otros en caso necesario. Esa puerta de entrada, en el ordenador es la conexión a Internet.
+
|}
+
<br>
+
<br>
+
  
En el caso de nuestra casa, si nos paramos a observar, la seguridad la representa la cerradura que tenemos en la puerta de entrada, las rejas de las ventanas que dan al jardín y el sistema de alarma. Si vivimos en un piso, sólo la puerta de entrada está protegida, y no mucho.<br>
+
¡¡¡Pasemos a rellenarlo!!!
  
¿Por qué? Porque seguro que hemos hecho una valoración de lo que tenemos dentro y hemos calculado que con una cerradura buena y una puerta blindada, alejará a muchos intrusos impacientes, pero si alguien se empeña en entrar, lo hará, incluso los cerrajeros que te abren la puerta cuando te dejas la llaves dentro, lo hacen en un parpadeo.<br>
+
Es típico necesitar tarde o temprano las librerias básicas de C, por ello, nuestras dos primeras lineas serán:
  
Pero establecemos una buena política en cuanto a normas de seguridad interior, para preservar nuestros bienes e incluso nuestra integridad, como por ejemplo, no encender fuegos dentro de la casa, las velas e inciensos lejos de las cortinas, prohibido fumar en la cama, la instalación de la electricidad y el gas revisados periódicamente, etc. Y con esto, vivimos tranquilos, no paranoicos. Ahora, el responsable de la seguridad informática del Pentágono, seguro que estará paranoico, y con razón, dado lo que guarda.<br>
+
<pre>
 +
#include &lt;math.h&gt;
 +
#include &lt;stdio.h&gt;
 +
</pre>
  
Hasta aquí, las consideraciones mínimas para un ordenador doméstico. Pero este ordenador estará conectado a la red, o sea abrimos la puerta para salir y, si la dejamos abierta, otros pueden entrar.<br>
+
(Relax, al final presentaremos el archivo al completo, es por ir viendo el desarrollo)
Veremos cómo mantener la puerta cerrada.
+
  
== Información general ==
+
Y seguidamente querremos las librerías de wxWidgets, por ahora sólo la básica:
  
* [[Seguridad proactiva]] - Un artículo de opciones de seguridad y ocultación para crear un volumen (partición) encriptado usando Truecrypt.
+
<pre>
 +
#include &lt;wx/wx.h&gt;
 +
</pre>
  
* [[Opciones por defecto no seguras]] - Configuraciones que lleva Ubuntu por defecto y que deberías cambiar si deseas usar servicios de red.
+
Bueno, esto ya es un gran paso, acabamos de importar las primeras librerias, todo un exito vaya :-D (este es el momento en el que te puedes bautizar como papá del programa)
  
== Actualizaciones de seguridad ==
+
¡¡¡Y ahora a crear nuestra aplicación!!!
  
* [[Actualizaciones automáticas de seguridad]] - cómo configurar Ubuntu para instalar las actualizaciones de seguridad automáticamente.
+
Nuestra aplicación será realmente una clase, y como es típico cuando se usan clases, usaremos un archivo cabecera (*.h) y un cpp, el cpp ya lo tenemos (te adelanto que este será un caso un poco especial, pero lo asumiremos, y después ya no volveremos a repetir un abuso asi, ya lo entenderás...)
  
== Contraseñas ==
+
Asi que repetimos operaciones:
 +
file/new.../file...
 +
Elegimos C/C++ header
 +
Le damos como nombre (recuerda lo de la ruta, usa el botoncito) "main.h", marcamos debug y release, y finalizamos...
  
* [[Contraseñas "fuertes"]] - cómo generar y usar contraseñas resistentes al crackeo en Ubuntu.
+
Nos sacará unos #define, simplemente los borramos (deja el archivo limpio). Y ahora, creemos nuestra clase.
  
== Herramientas de seguridad ==
+
Lo primero será darla un nombre, en nuestro caso la llamaremos "SampleApp" (como en los ejemplos de wxWidgets):
 +
<pre>
 +
class SampleApp
 +
{
 +
};
 +
</pre>
  
=== Cortafuegos ===
+
Ya hemos declarado la clase (de momento, en este post introducimos las cosas un poco <i>addhoc</i>, como verás ahora, pero todo esto forma parte de la documentación de wxWidgets, de la que hablaremos al final). Ahora vamos a hacer que esta clase herede las propiedades de otra clase de wxWidgets (así actuaremos normalmente con cualquier diálogo, lo iras viendo según vayamos introduciendo cosas), esta clase será wxApp, que es la que nos da control sobre una aplicación, quedando nuestro archivo así (novedades en negrita):
  
* [[iptables]].
+
  class SampleApp<b> : public wxApp</b>
 +
  {
 +
  };
  
=== Antivirus ===
 
  
* [[ClamAV]] - antivirus libre.
+
Bien, y ahora vamos a introducir un método, que será el que nos arranque la aplicación, quedando el archivo así:
  
=== SSH ===
+
  class SampleApp : public wxApp
 +
  {
 +
  <b>public:
 +
  virtual bool OnInit();</b>
 +
  };
  
* [[Servidor OpenSSH|OpenSSH]].
+
Bueno, recuperemos nuestro main.cpp, para ello, en el arbol vete a learn_0.01->Sources->main.cpp y hazle doble click...
 +
 
 +
En fin, ¿qué duda cabe?, necesitamos importar nuestra cabecera que acabamos de crear, asi que nuestra siguiente linea será:
 +
<pre>
 +
#include "main.h"
 +
</pre>
 +
 
 +
Y ahora tenemos que implementar el método que hemos declarado en main.h (recuerda: virtual bool OnInit()):
 +
<pre>
 +
/**********************************************************************/
 +
/************** This function run the application        *************/
 +
/************** can force some parameters too (p.ej size) *************/
 +
/**********************************************************************/
 +
bool SampleApp::OnInit()
 +
{
 +
return true; //true == run the app
 +
//no delete!!! it's implement in destroy();
 +
}
 +
</pre>
 +
 
 +
Y ya sólo nos falta hacer la llamada de wxWidgets (esta orden es del todo excepcional, simplemente quédate con que hace falta, porque no repetiremos cosas así muchas veces):
 +
 
 +
  /**********************************************************************/
 +
  /************** This function run the application        *************/
 +
  /************** can force some parameters too (p.ej size) *************/
 +
  /**********************************************************************/
 +
  <b>IMPLEMENT_APP(SampleApp)</b>
 +
  bool SampleApp::OnInit()
 +
  {
 +
  return true; //true == run the app
 +
  //no delete!!! it's implement in destroy();
 +
  }
 +
 
 +
¡Y ya está!, esta es nuestra primera aplicación, que efectivamente no hace nada... Finalmente main.cpp nos ha quedado asi:
 +
<pre>
 +
#include &lt;math.h&gt;
 +
#include &lt;stdio.h&gt;
 +
#include &lt;wx/wx.h&gt;
 +
#include "main.h"
 +
 
 +
/**********************************************************************/
 +
/************** This function run the application        *************/
 +
/************** can force some parameters too (p.ej size) *************/
 +
/**********************************************************************/
 +
 
 +
IMPLEMENT_APP(SampleApp)
 +
 
 +
bool SampleApp::OnInit()
 +
{
 +
return true; //true == run the app
 +
//no delete!!! it's implement in destroy();
 +
}
 +
</pre>
 +
 
 +
Y main.h asi:
 +
<pre>
 +
class SampleApp : public wxApp
 +
{
 +
public:
 +
virtual bool OnInit();
 +
};
 +
</pre>
 +
 
 +
Ahora vamos a compilar, veras que arriba tienes un icono con una rueda de engranajes azul, ese es el botón de compilar, y justo a su derecha pone &lt;&lt;build target: "Debug"&gt;&gt;, así que nada, no te cortes, compila tu version debug, y dale al play, a ver que tal...
 +
 
 +
No notarás que pase nada, porque no hay nada que pueda pasar, ya que nuestro programa no hace nada, como has podido comprobar...
 +
 
 +
Ahora vamos a añadir un TopFrame de lo mas básico... ¡¡¡Comenzemos a aprender!!!
 +
Pero eso será en el siguiente capítulo...
 +
 
 +
== Unas últimas notas ==
 +
Todo lo que vamos a hacer a partir de ahora irá fundamentado en la documentacion del API de wxWidgets, que puedes encontrar en multitud de sitios, no obstante, yo te recomiendo el archivo "wx.chm"...¿Y cómo lo puedo conseguir? pues necesitas un Windows...
 +
Vete a la pagina de wxWidgets (la primera que sale en google), y vete a downloads, alli bajate el instalable "wxMSW"
 +
En una maquina Windows (por ejemplo con Virtualbox, o en otro ordenador) instálalo... Y vete a <b>DIR</b>/docs/htmlhelp/ y allí lo encontrarás... (DIR es el directorio donde lo instalaste)
 +
Para poder verlo en Ubuntu, simplemente instala este paquete:
 +
<pre>
 +
sudo apt-get install xchm
 +
</pre>
 +
Necesitarás esa documentación, ya lo verás...
 +
 
 +
{| border=1 class="wikitable" align=center
 +
|-
 +
| style="text-align: center; border: 2px solid #8B673A; background-color: #F0E2C6; -moz-border-radius: 8px; margin: 10 10 10 10; padding: 5px; font-weight: bold;" | [[Capítulo 0.- Sobre como instalar wxWidgets y CodeBlocks]]
 +
| style="text-align: center; border: 2px solid #8B673A; background-color: #F0E2C6; -moz-border-radius: 8px; margin: 10 10 10 10; padding: 5px; font-weight: bold;" | [[Nuestra primera interfaz gráfica con CodeBlocks y wxWidgets]]
 +
| style="text-align: center; border: 2px solid #8B673A; background-color: #F0E2C6; -moz-border-radius: 8px; margin: 10 10 10 10; padding: 5px; font-weight: bold;" | [[Capítulo 2.- ¡Esta vivo! ¡vivoooooo! ¡JAJAJA!]]
 +
|}
  
== Enlaces útiles ==
 
  
* https://help.ubuntu.com/community/Security .
 
* http://www.nsa.gov/selinux/ .
 
  
[[Categoría:Seguridad]]
+
<!-- Categoría -->
 +
[[Categoría:Programación]]

Revisión de 20:27 8 ago 2008

Introducción

Este capítulo esta exento de contenidos que puedan servir de mucho para aprender, pero es necesario para poder seguir adelante, por eso el título del capítulo, porque realmente haremos cosas, pero no diremos porque las hacemos, simplemente asumiremos que es necesario hacerlas para poder empezar una aplicación con wxWidgets.

Construcción del programa 0

Bueno, vamos a ver si conseguimos crear nuestro programa cero...

Este va a ser nuestro paso fundamental, de donde empezaremos a crear, supongo que estas familiarizado con el tema de las clases en C++, aun asi iremos poquito a poco...

Bien, parece que lo primero será arrancar nuestro Code::Blocks

  • Por terminal, escribiendo lo siguiente:
    codeblocks %F
    
  • O por los menús:
    Aplicaciones/Programacion/Code::blocks
    

Nada mas arrancar nos da algún consejito, y despues nos invita amablemente a crear un proyecto, asi que dale al dibujito, o vete a:

file/new.../project...

Se que la emocion te embarga...¿pero qué es eso? ¿un wxwidgets project? ¡¡¡Pues cojámoslo!!!

Luego de dar un par de "siguientes" escoge un wxWidgets2.8.x (suponiendo que esa fue la versión que instalaste en el capítulo anterior)

Continuamos hasta la pantalla en la que tengamos que darle un nombre al proyecto. Yo, por limpieza (y porque he probado 100000 IDE's), decidí almacenar estos proyectos en una subcarpeta llamada "proyectos_codeblocks"

Asi pues, vete a tu directorio personal, y crea una carpeta con ese nombre, luego vuelve a codeblocks y mete estos datos: Project title: learn_0.01 Folder to create project in: /home/user/proyectos_codeblocks/ (donde user sera tu usuario) Project file name: Te lo rellenara el Resulting filename: Te lo rellenara el

<<Breve explicación: con esto Code::Blocks te creará la siguiente carpeta: /home/user/proyectos_codeblocks/learn_0.01/, y dentro de esa carpeta, te creará este archivo: learn_0.01.cbp. Bien, cuando quiera retomar tu proyecto, ese será el archivo que deberás abrir>>

Y dale a "next", mete tu nombre y demás datos, y vuelvele a dar a "next", apareciendo la pantalla del Designer... Nosotros no queremos Designer, pues aunque en un principio parece facilitar las cosas, mentira, solo las complica, nosotros vamos a aprender de verdad... Así que elige "None", y "Dialog Based", y dale a "next".

Ahora te aparecerá la pantalla del los compiladores, que esta bien como esta (asumo que te sale el compilador gcc), asi que dale a "next"...

<<Breve explicación: ahora ya esta preparado, tu proyecto se sitúa en /home/user/proyectos_codeblocks/learn_0.01/, y allí es donde deben estar tus *.cpp, y tus *.h. Respecto a los compilados, las versiones release (mas rapidas, pero no permiten debugar) estarán en la subcarpeta bin/Release, y las debug en bin/Debug>>

La última pantalla se refiere al proyecto inicial, nosotros somos unos valientes, asi que le daremos a "Use default..." y a "create empty project"

Bueno, si ves el Code::Blocks, a la izquierda tienes un árbol con tu workspace, pero esta vacío (tal y como le pedimos, porque vamos a aprender ¿no? :-D ). Así que no cabe duda, necesitamos un main, por tanto vamos a ello...

Pincha encima de learn_0.01 en el árbol, y vete a:

file/new.../file...

Y escoge "C/C++ Source", dale a "next" hasta que llegues a la pantalla de darle nombre... Code::blocks en esto esta quizás mal programado, y si le das directamente el nombre, te dirá que no es un directorio válido, así que dale al botoncito que tiene justo a la derecha del campo de texto, y escribe el nombre "main.cpp", y acepta, asi el ya te escribirá la ruta entera. Marca Debug y Release, y Acepta...

Y se te abre el solito... Podras encontrarlo tambien en el arbol expandiendo "learn_0.01->sources->main.cpp"

¡¡¡Pasemos a rellenarlo!!!

Es típico necesitar tarde o temprano las librerias básicas de C, por ello, nuestras dos primeras lineas serán:

#include <math.h>
#include <stdio.h>

(Relax, al final presentaremos el archivo al completo, es por ir viendo el desarrollo)

Y seguidamente querremos las librerías de wxWidgets, por ahora sólo la básica:

#include <wx/wx.h>

Bueno, esto ya es un gran paso, acabamos de importar las primeras librerias, todo un exito vaya :-D (este es el momento en el que te puedes bautizar como papá del programa)

¡¡¡Y ahora a crear nuestra aplicación!!!

Nuestra aplicación será realmente una clase, y como es típico cuando se usan clases, usaremos un archivo cabecera (*.h) y un cpp, el cpp ya lo tenemos (te adelanto que este será un caso un poco especial, pero lo asumiremos, y después ya no volveremos a repetir un abuso asi, ya lo entenderás...)

Asi que repetimos operaciones: file/new.../file... Elegimos C/C++ header Le damos como nombre (recuerda lo de la ruta, usa el botoncito) "main.h", marcamos debug y release, y finalizamos...

Nos sacará unos #define, simplemente los borramos (deja el archivo limpio). Y ahora, creemos nuestra clase.

Lo primero será darla un nombre, en nuestro caso la llamaremos "SampleApp" (como en los ejemplos de wxWidgets):

class SampleApp
{
};

Ya hemos declarado la clase (de momento, en este post introducimos las cosas un poco addhoc, como verás ahora, pero todo esto forma parte de la documentación de wxWidgets, de la que hablaremos al final). Ahora vamos a hacer que esta clase herede las propiedades de otra clase de wxWidgets (así actuaremos normalmente con cualquier diálogo, lo iras viendo según vayamos introduciendo cosas), esta clase será wxApp, que es la que nos da control sobre una aplicación, quedando nuestro archivo así (novedades en negrita):

 class SampleApp : public wxApp
 {
 };


Bien, y ahora vamos a introducir un método, que será el que nos arranque la aplicación, quedando el archivo así:

 class SampleApp : public wxApp
 {
 public:
 	virtual bool OnInit();
 };

Bueno, recuperemos nuestro main.cpp, para ello, en el arbol vete a learn_0.01->Sources->main.cpp y hazle doble click...

En fin, ¿qué duda cabe?, necesitamos importar nuestra cabecera que acabamos de crear, asi que nuestra siguiente linea será:

#include "main.h"

Y ahora tenemos que implementar el método que hemos declarado en main.h (recuerda: virtual bool OnInit()):

/**********************************************************************/
/************** This function run the application         *************/
/************** can force some parameters too (p.ej size) *************/
/**********************************************************************/
bool SampleApp::OnInit()
{
	return true; //true == run the app
	//no delete!!! it's implement in destroy();
}

Y ya sólo nos falta hacer la llamada de wxWidgets (esta orden es del todo excepcional, simplemente quédate con que hace falta, porque no repetiremos cosas así muchas veces):

 /**********************************************************************/
 /************** This function run the application         *************/
 /************** can force some parameters too (p.ej size) *************/
 /**********************************************************************/
 IMPLEMENT_APP(SampleApp)
 bool SampleApp::OnInit()
 {
 	return true; //true == run the app
 	//no delete!!! it's implement in destroy();
 }

¡Y ya está!, esta es nuestra primera aplicación, que efectivamente no hace nada... Finalmente main.cpp nos ha quedado asi:

#include <math.h>
#include <stdio.h>
#include <wx/wx.h>
#include "main.h"

/**********************************************************************/
/************** This function run the application         *************/
/************** can force some parameters too (p.ej size) *************/
/**********************************************************************/

IMPLEMENT_APP(SampleApp)

bool SampleApp::OnInit()
{
	return true; //true == run the app
	//no delete!!! it's implement in destroy();
}

Y main.h asi:

class SampleApp : public wxApp
{
public:
	virtual bool OnInit();
};

Ahora vamos a compilar, veras que arriba tienes un icono con una rueda de engranajes azul, ese es el botón de compilar, y justo a su derecha pone <<build target: "Debug">>, así que nada, no te cortes, compila tu version debug, y dale al play, a ver que tal...

No notarás que pase nada, porque no hay nada que pueda pasar, ya que nuestro programa no hace nada, como has podido comprobar...

Ahora vamos a añadir un TopFrame de lo mas básico... ¡¡¡Comenzemos a aprender!!! Pero eso será en el siguiente capítulo...

Unas últimas notas

Todo lo que vamos a hacer a partir de ahora irá fundamentado en la documentacion del API de wxWidgets, que puedes encontrar en multitud de sitios, no obstante, yo te recomiendo el archivo "wx.chm"...¿Y cómo lo puedo conseguir? pues necesitas un Windows... Vete a la pagina de wxWidgets (la primera que sale en google), y vete a downloads, alli bajate el instalable "wxMSW" En una maquina Windows (por ejemplo con Virtualbox, o en otro ordenador) instálalo... Y vete a DIR/docs/htmlhelp/ y allí lo encontrarás... (DIR es el directorio donde lo instalaste) Para poder verlo en Ubuntu, simplemente instala este paquete:

sudo apt-get install xchm

Necesitarás esa documentación, ya lo verás...

Capítulo 0.- Sobre como instalar wxWidgets y CodeBlocks Nuestra primera interfaz gráfica con CodeBlocks y wxWidgets Capítulo 2.- ¡Esta vivo! ¡vivoooooo! ¡JAJAJA!
Herramientas personales