¿Desea permitir que los usuarios con una cuenta estándar ejecuten aplicaciones con privilegios de administrador sin UAC o una solicitud de contraseña? Entonces te diré cómo hacerlo. Crearemos un atajo usando el comando runas / savecredque guarda la contraseña. Observo que esto se puede considerar un agujero de seguridad: un usuario común podrá usar runas / savecred para ejecutar cualquier comando en nombre del administrador sin ingresar una contraseña. Sin embargo, en algunas situaciones esto puede ser útil, por ejemplo, si desea que su hijo de una cuenta estándar pueda ejecutar aplicaciones como administrador sin preguntarle.
Habilitar cuenta de administrador
En primer lugar, debe habilitar la cuenta de administrador integrada, que está deshabilitada de forma predeterminada. Entonces, haga clic derecho en el acceso directo de la línea de comando y seleccione "Ejecutar como administrador".
En la ventana del símbolo del sistema que se abre, ejecute el siguiente comando:
administrador de usuario neto / activo: sí
La cuenta ahora está habilitada, aunque sin contraseña. Para establecer una contraseña, abra el Panel de control, seleccione la categoría Cuentas de usuario y Seguridad familiar, y luego abra el menú Cuentas de usuario. A continuación, haga clic en el enlace "Administrar otra cuenta".
Seleccione una cuenta de administrador, haga clic en el botón "Crear contraseña" y cree una contraseña para la cuenta de administrador.
Crea un atajo
Ahora crearemos un acceso directo que iniciará la aplicación con privilegios de administrador. Haga clic derecho en el escritorio, seleccione "Crear" y luego haga clic en "Acceso directo".
En la ventana que se abre, ingrese el comando del siguiente tipo:
runas / usuario: Nombre del equipo\\ Administrador / savecred " C: \\ Path \\ To \\ Program.exe“
Tenga en cuenta que necesita reemplazar Nombre del equipo en nombre de su computadora, y C: \\ Path \\ To \\ Program.exe a la ruta completa al programa que desea ejecutar. Por ejemplo, si el nombre de la computadora es Laptop y el programa que desea ejecutar es Auslogics BoostSpeed, debe ingresar la siguiente ruta:
runas / user: Laptop \\ Administrator / savecred "C: \\ Archivos de programa \\ Auslogics \\ Auslogics BoostSpeed \u200b\u200b\\ BoostSpeed.exe"
En la siguiente ventana, ingrese un nombre para el acceso directo. Si lo desea, puede seleccionar un icono para un nuevo acceso directo: haga clic derecho sobre él y seleccione "Propiedades".
En el cuadro de diálogo "Propiedades", haga clic en el botón "Cambiar icono" y seleccione el apropiado.
Cuando haga doble clic en el acceso directo por primera vez, se le pedirá que ingrese la contraseña de la cuenta de administrador que creó anteriormente.
Esta contraseña se guardará: la próxima vez que ejecute el programa, ya no tendrá que volver a ingresarla.
Como se mencionó anteriormente, en las cuentas estándar, los usuarios pueden ejecutar cualquier programa con derechos de administrador sin ingresar una contraseña (usando el comando runas / savecred), así que tenga esto en cuenta.
La contraseña del administrador se almacena en el "Administrador de credenciales". Si desea eliminar la contraseña guardada, puede hacerlo desde allí.
¡Que tengas un buen día!
Algunas aplicaciones de Windows requieren permisos elevados, y debe ejecutarlas como administrador. La consulta " Control de cuenta de usuario"(Control de cuenta de usuario o Uac), en el que el sistema solicita su consentimiento para iniciar la aplicación.
Muchos usuarios creen incorrectamente que el "Control de cuentas de usuario" solo interfiere y lo deshabilita. Al mismo tiempo, la seguridad informática se ve seriamente afectada. El consentimiento del usuario para iniciar aplicaciones ya no es necesario, y cualquier programa malicioso puede ejecutarse y ejecutarse sin obstáculos. La presencia de un antivirus tampoco puede garantizar al 100% la seguridad informática.
En este artículo, le diré cómo simplificar el proceso de lanzamiento de aplicaciones seleccionadas en nombre del administrador sin deshabilitar UAC (total o parcialmente) y sin comprometer la seguridad.
Para ejecutar la aplicación como administrador, puede usar varios métodos:
Como ejemplo, correremos línea de comando (cmd) como administrador.
Método n. ° 1 (normal): comience con el botón derecho del mouse (se muestra la solicitud UAC)
Haga clic derecho en el ícono aplicación deseada y seleccione " Ejecutar como administrador":
Método número 2: comience a usar " Ctrl + Shift + Enter"(Se muestra la solicitud UAC)
Haga clic en Inicio, en la barra de búsqueda, escriba el comando deseado y haga clic en Ctrl + Shift + Enter.
Método n. ° 3: configure el inicio como administrador en las propiedades de acceso directo (se muestra la solicitud UAC)
Haga clic derecho en el acceso directo deseado y seleccione " Las propiedades".
Ve a la " Atajo"clic" Opcional"marque la casilla" Ejecutar como administrador":
O ve al " Compatibilidad"y marque la casilla" Ejecute este programa como administrador":
Método número 4: simplifique el inicio de las aplicaciones seleccionadas utilizando el programador de tareas (no se muestra la solicitud UAC)
Importante! Este método solo funciona para cuentas en el grupo. Administradores. En usuarios ordinarios no funcionará, porque sus derechos se limitan al techo.
Pasamos a la forma más interesante. Si hay una aplicación que ejecuta constantemente y la recibe de un fabricante de software confiable, por ejemplo, esta aplicación de Windows, puede simplificar el inicio. Crear un atajo para programa deseado No toma más de 2 minutos y esto eliminará las acciones innecesarias en el futuro. Lanzamos planificador de tareas (Inicio---> Todos los programas ---> Estándar---> Oficina---> Programador de tareas) y haga clic en " Crear tarea":
Indicar Nombrepara una nueva tarea y marque la casilla " Realizar con los más altos derechos":
Ir a la pestaña Accioneshaga clic en " Crear", en la ventana siguiente, haga clic en" Revisar":
Especifique la ruta a la aplicación deseada y haga clic en " Abierto":
Ampliar imagen
Empujar " Ok":
Cierre el programador y continúe para crear un acceso directo.
Para crear un acceso directo en el escritorio, haga clic derecho, seleccione " Crear" ---> "Atajo":
En el campo Ubicación del objeto entrar:
Schtasks / run / tn cmd_admin
donde cmd_admin - nombre de la tarea que creamos. Si el nombre contiene espacios, debe estar entre comillas.
Establezca el nombre de la etiqueta:
Ampliar imagen
Acceso directo creado y listo para usar.
Para cambiar el icono: haga clic con el botón derecho en el acceso directo, seleccione " Las propiedades":
Ve a la " Atajo"y haga clic en" Cambiar icono":
"Revisar..."
Especifique la ruta al programa:
Ampliar imagen
Seleccione el icono deseado y cierre ambas ventanas con el " Ok":
Ahora, el lanzamiento de la aplicación deseada como administrador se realiza haciendo doble clic en el acceso directo creado, mientras que la solicitud de UAC no se muestra y la seguridad permanece intacta.
Utilidad para la automatización del "Método No. 4"
En caso de que necesite crear accesos directos para una gran cantidad de programas, es conveniente utilizar la utilidad.
Trabajar con la utilidad se reduce a dos simples pasos:
- Instalación
- Arrastre y suelte el archivo ejecutable (* .exe, * .bat, * .cmd) en el acceso directo de la utilidad:
Enfoque automático en un programa en ejecución
Los detalles de iniciar aplicaciones desde el programador es que el foco en la ventana no está traducido y, por ejemplo, para escribir un comando en la línea de comando, debe hacer clic en la ventana adicionalmente. Tal comportamiento puede ayudar a automatizar las operaciones programadas de rutina, pero para el "Método No. 4" esto no siempre es conveniente.
Hay varios métodos para "evitar". Funcionan de manera un poco diferente, así que elige el más adecuado. El primero es más conveniente para ejecutar programas y el segundo para ejecutar scripts.
Agregar al crear la tarea:
Usando el comando de inicio
Programa o script:
Argumentos:
/ c start / d "ruta_programa" nombre_archivo.exe
/ c start / d "C: \\ Windows \\ System32 \\" cmd.exe
Usando la utilidad NirCmd
Programa o script:
Path_k_nircmd \\ nircmd.exe
Argumentos:
Exec show "ruta_programa \\ nombre_archivo.exe"
Exec muestra "C: \\ Windows \\ System32 \\ cmd.exe"
Iniciar el cuadro de diálogo Ejecutar como administrador
De manera similar al inicio de la línea de comando, puede configurar el inicio de " Correr", y los comandos ingresados \u200b\u200btambién se ejecutarán en nombre del administrador. La conveniencia de este enfoque es que la lista de comandos usados \u200b\u200bpreviamente se guarda y puede seleccionar el deseado de la lista.
Al crear una tarea en el planificador, en el " Creación de acciones"indicar:
en el campo " Programa o guión":
Rundll32
en el campo " Agregar argumentos":
Shell32.dll, # 61
Descargue la utilidad, descomprímalo. Iniciamos la línea de comando, ingresamos el comando deseado, la sintaxis es bastante simple:
<путь к утилите> <путь к нужному приложению>
Se muestra un aviso de UAC y la aplicación se inicia como administrador.
Nota: En contexto menú de Windows 7 hay una función muy conveniente para copiar la ruta del archivo: mantener Cambio, haga clic derecho en el archivo, seleccione " Copiar como ruta".
Ejecutar programas por un usuario como administrador sin ingresar una contraseña de administrador
Importante! Este método no es seguro porque permite a un usuario con derechos limitados ejecutar código con todos los derechos. Un usuario astuto o malware puede aprovechar esto y comprometer el sistema.
Consideremos una tarea más interesante: su cuenta registro de Windows pertenece al grupo de administradores, hay uno o varios cuentasincluido en el grupo de usuarios. El usuario necesita ejecutar un programa que requiera la elevación de privilegios. Por lo general, se ve así: el usuario hace clic con el botón derecho en el archivo y selecciona "Ejecutar como administrador", y se muestra una solicitud para ingresar la contraseña de administrador:
Por supuesto, dar una contraseña de administrador a los usuarios no es una buena idea. Para solucionar esto, utilizaremos la utilidad AdmiLink de Alexei Kuryakin. Con él, el administrador puede crear un acceso directo para que el usuario inicie el programa necesario, mientras que ingresar la contraseña del administrador solo se requiere 1 vez, al crear el acceso directo. Cuando el usuario inicia el programa, la contraseña se transmitirá en forma cifrada.
Este método funcionará si es posible iniciar el programa solo en nombre del administrador y el desarrollador no olvidó indicar esta condición en el manifiesto. Sin embargo, sigue siendo un gran número programas antiguos o programas que se pueden iniciar como en modo normal, y en nombre del administrador (en este caso, habrá disponible un conjunto diferente de funciones). Cuando intenta ejecutar un programa de este tipo con AdmiLink, se inicia en modo normal (sin privilegios administrativos). Y si intenta poner una marca de verificación en "Método número 3. Se guarda el estilo original del autor.
¿Qué sucede si necesita ejecutar el programa, pero no desea instalarlo? ¡Instale cero al rescate!
Miles de millones de personas en todo el mundo usan computadoras o computadoras portátiles en la sala de operaciones. sistema de Windows. Por lo general, instalamos programas, después de lo cual toman espacio libre en disco y uso memoria de acceso aleatorio. Esto reduce la velocidad de la computadora.
Hoy le diremos cómo puede aumentar el rendimiento de la computadora y reducir la carga en la memoria. Para hacer esto, debe ejecutar los programas necesarios sin instalarlos.
¿Cómo ejecutar el programa sin instalación?
1. Descargue Zero Install.
Primero, descargue el software Zero Install, que le permite ejecutar programas sin tener que instalarlos en su computadora.
2. Instale Zero Install.
Una vez que haya descargado Zero Install, haga doble clic en el archivo para instalarlo. Entonces corre nuevo programa en tu computadora
3. Haga clic enalbañilería "Catálogo".
Una vez que Zero Install se esté ejecutando en la computadora o portátil con windows, debe ir a la pestaña "Catálogo". Haga clic en el botón "Actualizar lista" para actualizar la lista de programas disponibles.
4. Seleccione un programa para ejecutar.
Mira con cuidado lista completa Programas disponibles. Si encuentra el programa que necesita, selecciónelo y haga clic en "Ejecutar". Algunos programas pueden elegir navegador firefox o Mozilla para correr. Solo espera la descarga completa. software, después de lo cual puede ejecutarlo en su computadora sin instalarlo.
Resumen
Si su computadora no tiene suficiente memoria o energía libre para ejecutar el programa, puede usar Zero Install. Creo que esta es una excelente manera de no ensuciar su computadora con los programas que necesita al mismo tiempo.
Además, es posible que su computadora no tenga suficiente energía para ejecutar ciertos programas, por ejemplo, Eclipse IDE, JetBrains, NetBeans, etc. Estos son programas realmente difíciles para desarrolladores que consumen una gran cantidad de RAM.
Zero Install ayudará a iniciar estos y muchos otros programas, sin instalarlos en una computadora.
Lo más importante no se describió con suficiente detalle: ¿cómo ejecutar este código en hardware real? Cómo crear tu propio disco de arranque? En este artículo, responderemos a todas estas preguntas en detalle (en parte, estos temas se discutieron en el artículo anterior, pero por conveniencia de leer nos permitimos una pequeña duplicación de material).
En Internet hay muchas descripciones y tutoriales sobre cómo escribir su propio mini-SO, incluso hay cientos de pequeños OS-pasatiempos listos para usar. Uno de los recursos más valiosos sobre este tema, que me gustaría destacar, es el portal osdev.org. Para complementar el artículo anterior sobre PCI (y la capacidad de escribir artículos posteriores sobre las diversas funciones que están presentes en cualquier sistema operativo moderno), describiremos instrucciones paso a paso para crear un disco de arranque con el programa habitual en C. Intentamos escribir lo más detallado posible para poder resolverlo por nuestra cuenta.
Entonces, el objetivo: haber gastado el menor esfuerzo posible, crear su propia unidad flash USB de arranque, que simplemente imprime el clásico "Hello World" en la pantalla de una computadora.
Para ser más precisos, necesitamos "entrar" en modo protegido con direccionamiento de página deshabilitado e interrupciones, el modo de procesador más simple con el comportamiento habitual para un programa de consola simple. La forma más razonable de lograr este objetivo es construir un núcleo que admita el formato de arranque múltiple y cargarlo usando el popular grub del cargador de arranque. Una alternativa a esta solución es escribir su propio registro de inicio de volumen (VBR), que cargaría su propio cargador (cargador) escrito. Un gestor de arranque decente, al menos, debería poder trabajar con el disco, con el sistema de archivos y analizar imágenes de elfos. Esto significa que necesita escribir mucho código de ensamblador y mucho código C. En resumen, es más fácil usar Grub, que ya sabe cómo hacer todo lo necesario.
Para comenzar, se requiere un cierto conjunto de compiladores y utilidades para otras acciones. La forma más fácil es usar algún tipo de Linux (por ejemplo, Ubuntu), ya que ya contendrá todo lo que necesita para crear una unidad flash de arranque. Si está acostumbrado a trabajar en Windows, puede configurar una máquina virtual con Linux (usando Virtual Box o VMware Workstation).
Si está utilizando Linux Ubuntu, primero debe instalar varias utilidades:
1. Grub. Para hacer esto, use el comando:
Sudo apt-get install grub
2. Qemu. Es necesario probar y depurar todo rápidamente (Enlace al artículo sobre el depurador), para esto el comando es similar:
Sudo apt-get install qemu
Ahora nuestro plan se ve así:
1. Cree un programa en C que imprima una línea en la pantalla.
2. compile de ella una imagen (kernel.bin) en formato miniboot para que esté disponible para descargar usando GRUB.
3. Cree un archivo de imagen de disco de arranque y formatee.
4. Instale Grub en esta imagen.
5. copie el programa creado (kernel.bin) en el disco.
6. grabar la imagen en medios físicos o ejecutarlo en qemu.
y el proceso de arranque del sistema:
Para que funcione, deberá crear varios archivos y directorios:
Paso 1. Crear el código del programa de destino (kernel):
Cree un archivo kernel.c que contendrá el siguiente código que imprime un mensaje en la pantalla:
#include "printf.h" #include "screen.h" #include "types.h" void main (void) (clear_screen (); printf ("n \u003e\u003e\u003e Hello World! n");)
Aquí todo es familiar y simple. Agregar las funciones printf y clear_screen se discutirá más adelante. Mientras tanto, debe complementar este código con todo lo necesario para que Grub lo pueda cargar.
Para que el núcleo esté en formato de arranque múltiple, necesita la siguiente estructura en los primeros 8 kilobytes de la imagen del núcleo:
Si se cumplen todas estas condiciones, Grub pasa a través de los registros% eax y% ebx un puntero a la estructura de información de arranque múltiple y el valor 0x1BADB002, respectivamente. La estructura de información de arranque múltiple contiene diversa informacion, incluida una lista de módulos cargados y su ubicación, que pueden ser necesarios para una mayor carga del sistema.
Para que el archivo del programa contenga las firmas necesarias, cree un archivo loader.s con el siguiente contenido:
Texto .global loader # haciendo que el punto de entrada sea visible para el enlazador # configurando el encabezado de arranque múltiple - vea los documentos de GRUB para obtener más detalles. el encabezado .set CHECKSUM, - (MAGIC + FLAGS) # suma de verificación requerida .align 4 .long MAGIC .long FLAGS .long CHECKSUM # reserva el espacio inicial de la pila del kernel .set STACKSIZE, 0x4000 # es decir, 16k. .lcomm stack, STACKSIZE # reserve 16k stack .comm mbd, 4 # usaremos esto en kmain .comm magic, 4 # usaremos esto en kmain loader: movl $ (stack + STACKSIZE),% esp # configuramos la pila movl% eax, magic # Número mágico de arranque múltiple movl% ebx, mbd # Estructura de datos de arranque múltiple llamada main # código de llamada C cli hang: hlt # detener la máquina debe kernel return jmp hang
Considere el código con más detalle. Este código casi no ha cambiado desde wiki.osdev.org/Bare_Bones. Como se usa gcc para la compilación, se usa la sintaxis GAS. Echemos un vistazo más de cerca a lo que hace este código.
Todo el código posterior caerá en la sección ejecutable .text.
Cargador global
Declaramos el símbolo del cargador visible para el enlazador. Esto es necesario ya que el vinculador utilizará el cargador como punto de entrada.
Establecer BANDERAS, 0x0 # asignar BANDERAS \u003d 0x0 .set MAGIC, 0x1BADB002 # asignar MAGIC \u003d 0x1BADB002 .set CHECKSUM, - (MAGIC + FLAGS) # asignar CHECKSUM \u003d - (MAGIC + FLAGS) .alinear 4 # alinear los datos subsiguientes por 4 bytes. largo MAGIC # coloca el valor actual MAGIC .Long FLAGS # coloca el valor actual FLAGS. long CHECKSUM # coloca el valor actual CHECKSUM
Este código forma una firma del formato de arranque múltiple. La directiva .set establece el valor del carácter en la expresión a la derecha de la coma. La directiva .align 4 alinea los contenidos posteriores a 4 bytes. La directiva .long almacena el valor en cuatro bytes posteriores.
Establezca STACKSIZE, 0x4000 # asignar STACKSIZE \u003d 0x4000 .lcomm stack, STACKSIZE # reserve STACKSIZE bytes. stack se refiere a range.comm mbd, 4 # reserva 4 bytes para la variable mdb en el área COMÚN .comm magic, 4 # reserva 4 bytes para la variable mágica en el área COMÚN
Durante el proceso de arranque, grub no configura la pila, y lo primero que debe hacer el núcleo es configurar la pila, para esto reservamos 0x4000 (16Kb) bytes. La directiva .lcomm reserva en la sección .bss el número de bytes especificado después del punto decimal. La pila de nombres solo será visible en el archivo compilado. La directiva .comm hace lo mismo que .lcomm, pero el nombre del símbolo se declarará globalmente. Esto significa que al escribir la siguiente línea en código C, podemos usarla.
extern int magic
Y ahora la última parte:
Cargador: movl $ (stack + STACKSIZE),% esp # inicializar stack movl% eax, magic # write% eax a la dirección mágica movl% ebx, mbd # write% ebx a mbd llamar a main # call main cli function # desconectar interrupción de bloqueo de hardware: hlt # detiene el procesador hasta que se produce la interrupción jmp cuelga # salta para colgar la etiqueta
La primera instrucción guarda el valor de la parte superior de la pila en el registro% esp. A medida que la pila crece, la dirección del final del rango asignado para la pila se escribe en% esp. Las dos instrucciones posteriores almacenan en los rangos previamente reservados de 4 bytes los valores que Grub pasa en los registros% eax,% ebx. Entonces se llama a la función principal, que ya está escrita en C. Si regresa de este procedimiento, el procesador realizará un bucle.
Paso 2. Preparación de código adicional para el programa (biblioteca del sistema):
Como todo el programa está escrito desde cero, la función printf debe escribirse desde cero. Para hacer esto, prepare varios archivos.
Cree una carpeta común e incluir:
Mkdir común mkdir incluye
Cree un archivo commonprintf.c que contendrá la implementación de la función familiar printf. Este archivo completo puede tomarse del proyecto www.bitvisor.org/. La ruta al archivo en las fuentes de bitvisor: core / printf.c. En el archivo printf.c copiado de Bitvisor, para usar en el programa de destino, debe reemplazar las líneas:
#include "initfunc.h" #include "printf.h" #include "putchar.h" #include "spinlock.h"
por línea:
#include "types.h" #include "stdarg.h" #include "screen.h"
Luego, elimine la función printf_init_global y todas sus referencias en este archivo:
Vacío estático printf_init_global (void) (spinlock_init (& printf_lock);) INITFUNC ("global0", printf_init_global);
Luego elimine la variable printf_lock y todas sus referencias en este archivo:
Spinlock_t estático printf_lock; ... spinlock_lock (& \u200b\u200bprintf_lock); ... spinlock_unlock (& \u200b\u200bprintf_lock);
La función printf usa la función putchar, que también debe escribirse. Para hacer esto, cree un archivo commonscreen.c con el siguiente contenido:
#include "types.h" #define GREEN 0x2 #define MAX_COL 80 // Número máximo de columnas #define MAX_ROW 25 // Número máximo de filas #define VRAM_SIZE (MAX_COL * MAX_ROW) // Tamaño de la pantalla, en resumen "s # define DEF_VRAM_BASE 0xb8000 // Base predeterminada para la memoria de video estática sin firmar char curr_col \u003d 0; estática sin firmar char curr_row \u003d 0; // Escribe el carácter en la ubicación actual de la pantalla #define PUT (c) (((unsigned short *) (DEF_VRAM_BASE)) [ (curr_row * MAX_COL) + curr_col] \u003d (VERDE<< 8) | (c)) // Place a character on next screen position static void cons_putc(int c) { switch (c) { case "t": do { cons_putc(" "); } while ((curr_col % 8) != 0); break; case "r": curr_col = 0; break; case "n": curr_row += 1; if (curr_row >\u003d MAX_ROW) (curr_row \u003d 0;) break; caso "b": if (curr_col\u003e 0) (curr_col - \u003d 1; PUT ("");) break; predeterminado: PUT (c); curr_col + \u003d 1; if (curr_col\u003e \u003d MAX_COL) (curr_col \u003d 0; curr_row + \u003d 1; if (curr_row\u003e \u003d MAX_ROW) (curr_row \u003d 0;))); ) void putchar (int c) (if (c \u003d\u003d "n") cons_putc ("r"); cons_putc (c);) void clear_screen (void) (curr_col \u003d 0; curr_row \u003d 0; int i; for (i \u003d 0; i< VRAM_SIZE; i++) cons_putc(" "); curr_col = 0; curr_row = 0; }
El código especificado contiene una lógica simple para imprimir caracteres en la pantalla en modo texto. En este modo, se utilizan dos bytes para grabar el carácter (uno con el código de caracteres, el otro con sus atributos), escrito directamente en la memoria de video que se muestra inmediatamente en la pantalla y que comienza con la dirección 0xB8000. La resolución de la pantalla es de 80x25 caracteres. El personaje se imprime directamente usando la macro PUT.
Ahora solo faltan algunos archivos de encabezado:
1. El archivo incluye screen.h. Declara una función putchar, que se utiliza en la función printf. Contenido del archivo:
#ifndef _SCREEN_H #define _SCREEN_H void clear_screen (void); vacío putchar (int c); #endif
2. El archivo includeprintf.h. Declara la función printf, que se usa en main. Contenido del archivo:
#ifndef _PRINTF_H #define _PRINTF_H int printf (formato const char *, ...); #endif
3. El archivo incluyestdarg.h. Declara funciones para iterar sobre argumentos cuyo número no se conoce de antemano. El archivo completo está tomado del proyecto www.bitvisor.org/. La ruta al archivo en el código del proyecto de bitvisor: includecorestdarg.h.
4. El archivo includetypes.h. Declara NULL y size_t. Contenido del archivo:
#ifndef _TYPES_H #define _TYPES_H #define NULL 0 typedef unsigned int size_t; #endif
Por lo tanto, las carpetas de inclusión y comunes contienen el código mínimo de la biblioteca del sistema que cualquier programa necesita.
Paso 3. Crear un script para el enlazador:
Creamos el archivo linker.ld, que será utilizado por el vinculador para generar el archivo de programa de destino (kernel.bin). El archivo debe contener lo siguiente:
ENTRADA (cargador) LMA \u003d 0x00100000; SECCIONES (. \u003d LMA; .multiboot ALIGN (0x1000): (loader.o (.text)) .text ALIGN (0x1000): (* (. Text)) .rodata ALIGN (0x1000): (* (. Rodata *) ) .data ALIGN (0x1000): (* (. data)) .bss: (* (COMMON) * (. bss)) / DISCARD /: (* (. comment)))
La función incorporada ENTRY () le permite establecer el punto de entrada para nuestro kernel. Es en esta dirección que grub pasará el control después de que arranque el núcleo. Usando este script, el enlazador creará un archivo binario en formato ELF. Un archivo ELF consta de un conjunto de segmentos y secciones. La lista de segmentos está contenida en la tabla de encabezado del Programa, la lista de secciones en la tabla de encabezado de Sección. El enlazador funciona con secciones, el cargador de imágenes (en nuestro caso, GRUB) con segmentos.
Como puede ver en la figura, los segmentos consisten en secciones. Uno de los campos que describen la sección es la dirección virtual en la que la sección debe estar en el momento de la ejecución. De hecho, un segmento tiene 2 campos que describen su ubicación: la dirección virtual del segmento y la dirección física del segmento. La dirección virtual del segmento es la dirección virtual del primer byte del segmento en el momento en que se ejecuta el código, la dirección física del segmento es la dirección física en la que se debe cargar el segmento. Para las aplicaciones, estas direcciones siempre coinciden. Grub descarga segmentos de imagen en su dirección física. Como Grub no configura el direccionamiento de página, la dirección virtual del segmento debe coincidir con su dirección física, ya que en nuestro programa la memoria virtual tampoco está configurada.
LMA
Esta expresión indica al vinculador que todas las secciones posteriores están después de la dirección de LMA.
ALINEAR (0x1000)
La directiva anterior significa que la sección está alineada a 0x1000 bytes.
Multiiboot ALIGN (0x1000): (loader.o (.text))
Una sección separada de arranque múltiple, que incluye la sección .text del archivo loader.o, está diseñada para garantizar que la firma del formato de arranque múltiple llegue a los primeros 8kb de la imagen del núcleo.
Bss: (* (COMÚN) * (. Bss))
* (COMÚN) es el área en la que la memoria está reservada por las instrucciones .com y.lcomm. Lo colocamos en la sección .bss.
/ DESCARTAR /: (* (. Comentario))
Todas las secciones marcadas como DESCARGAR se eliminan de la imagen. En este caso, eliminamos la sección .comment, que contiene información sobre la versión del enlazador.
Ahora compile el código en un archivo binario con los siguientes comandos:
Como -o loader.o loader.s gcc -Iinclude -Wall -fno-builtin -nostdinc -nostdlib -o kernel.o -c kernel.c gcc -Iinclude -Wall -fno-builtin -nostdinc -nostdlib -o printf.o -c común / printf.c gcc -Incluir -Wall -fno-builtin -nostdinc -nostdlib -o screen.o -c común / screen.c ld -T linker.ld -o kernel.bin kernel.o screen.o printf .o loader.o
Usando objdump's, veamos cómo se ve la imagen del núcleo después de vincular:
Objdump -ph ./kernel.bin
Como puede ver, las secciones de la imagen coinciden con las que describimos en el script del vinculador. El enlazador formó 3 segmentos a partir de las secciones descritas. El primer segmento incluye secciones.multiboot, .text, .rodata y tiene una dirección virtual y física 0x00100000. El segundo segmento contiene las secciones .data y .bss y se encuentra en 0x00104000. Entonces todo está listo para descargar este archivo usando Grub.
Paso 4. Preparando el gestor de arranque Grub:
Crear carpeta grub:
Comida de Mkdir
Copie varios archivos Grub en esta carpeta que sean necesarios para instalarlo en la imagen (los siguientes archivos existen si Grub está instalado en el sistema). Para hacer esto, ejecute los siguientes comandos:
Cp / usr / lib / grub / i386-pc / stage1 ./grub/ cp / usr / lib / grub / i386-pc / stage2 ./grub/ cp / usr / lib / grub / i386-pc / fat_stage1_5 ./grub / /
Cree un archivo grub / menu.lst con el siguiente contenido:
Tiempo de espera 3 predeterminado 0 título mini_os root (hd0,0) kernel /kernel.bin
Paso 5. Automatizar y crear una imagen de arranque:
Para automatizar el proceso de construcción, usaremos la utilidad make. Para hacer esto, cree un archivo MAKE que compilará código fuente, compila el kernel y crea una imagen de arranque. El archivo MAKE debe tener los siguientes contenidos:
CC \u003d gcc CFLAGS \u003d -Wall -fno-builtin -nostdinc -nostdlib LD \u003d ld OBJFILES \u003d loader.o common / printf.o common / screen.o kernel.o image: @echo "Creando hdd.img ..." @ dd if \u003d / dev / zero of \u003d. / hdd.img bs \u003d 512 count \u003d 16065 1\u003e / dev / null 2\u003e & 1 @echo "Creando la primera partición FAT32 de arranque ..." @losetup / dev / loop1 ./hdd .img @ (echo c; echo u; echo n; echo p; echo 1; echo; echo; echo a; echo 1; echo t; echo c; echo w;) | fdisk / dev / loop1 1\u003e / dev / null 2\u003e & 1 || true @echo "Montaje de la partición en / dev / loop2 ..." @losetup / dev / loop2 ./hdd.img --offset `echo` fdisk -lu / dev / loop1 | sed -n 10p | awk "(imprimir $$ 3)" `* 512 | bc` --sizelimit `echo` fdisk -lu / dev / loop1 | sed -n 10p | awk "(imprimir $$ 4)" `* 512 | bc` @losetup -d / dev / loop1 @echo "Formatear partición ..." @mkdosfs / dev / loop2 @echo "Copiar kernel y archivos grub en la partición ..." @mkdir -p tempdir @mount / dev / loop2 tempdir @mkdir tempdir / boot @cp -r grub tempdir / boot / @cp kernel.bin tempdir / @sleep 1 @umount / dev / loop2 @rm -r tempdir @losetup -d / dev / loop2 @echo "Instalación de GRUB. .. Dispositivo "@echo" (hd0) hdd.img n root (hd0,0) n setup (hd0) n quitn "| grub - lote 1\u003e / dev / null @echo "¡Listo!" all: kernel.bin rebuild: clean all .s.o: como -o $ @ $< .c.o: $(CC) -Iinclude $(CFLAGS) -o $@ -c $< kernel.bin: $(OBJFILES) $(LD) -T linker.ld -o $@ $^ clean: rm -f $(OBJFILES) hdd.img kernel.bin
En el archivo se declaran dos objetivos principales: todos: compila el núcleo y la imagen, lo que crea el disco de arranque. Todo el destino, como el archivo MAKE habitual, contiene submetas.s.o y.c.o que compilan archivos * .s y * .c en archivos de objetos (* .o), así como un destino para generar kernel.bin, que llama al vinculador con el script creado anteriormente. Estos objetivos ejecutan exactamente los mismos comandos que se enumeran en el paso 3.
De mayor interés aquí es la creación de imagen de arranque hdd.img (imagen de destino). Consideremos por etapas cómo sucede esto.
Dd if \u003d / dev / zero of \u003d. / Hdd.img bs \u003d 512 count \u003d 16065 1\u003e / dev / null 2\u003e & 1
Este comando crea una imagen con la que se llevará a cabo más trabajo. El número de sectores no se eligió al azar: 16065 \u003d 255 * 63. De manera predeterminada, fdsik trabaja con el disco como si tuviera geometría CHS en la que Headers (H) \u003d 255, Sectores (S) \u003d 63 y Cylinders © dependen del tamaño del disco . Por lo tanto, el tamaño mínimo de disco con el que la utilidad fdsik puede trabajar sin cambiar la geometría predeterminada es 512 * 255 * 63 * 1 \u003d 8225280 bytes, donde 512 es el tamaño del sector y 1 es el número de cilindros.
A continuación, se crea una tabla de partición:
Losetup / dev / loop1 ./hdd.img (echo c; echo u; echo n; echo p; echo 1; echo; echo; echo a; echo 1; echo t; echo c; echo w;) | fdisk / dev / loop1 1\u003e / dev / null 2\u003e & 1 || cierto
El primer comando monta el archivo hdd.img en el dispositivo de bloque / dev / loop1, lo que le permite trabajar con el archivo como dispositivo. El segundo comando crea la tabla de particiones en el dispositivo / dev / loop1, en el que hay 1 primario partición de arranque un disco que abarca todo el disco con la etiqueta del sistema de archivos FAT32.
Luego formateamos la sección creada. Para hacer esto, móntelo como un dispositivo de bloque y realice el formateo.
Losetup / dev / loop2 ./hdd.img --offset `echo` fdisk -lu / dev / loop1 | sed -n 10p | awk "(imprimir $$ 3)" `* 512 | bc` --sizelimit `echo` fdisk -lu / dev / loop1 | sed -n 10p | awk "(imprimir $$ 4)" `* 512 | bc` losetup -d / dev / loop1
El primer comando monta la partición creada previamente en el dispositivo / dev / loop2. La opción –offset especifica la dirección del comienzo de la sección y –sizelimit la dirección del final de la sección. Ambos parámetros se obtienen utilizando el comando fdisk.
Mkdosfs / dev / loop2
La utilidad mkdosfs formatea una partición en sistema de archivos FAT32.
Para el ensamblaje directo del kernel, los comandos discutidos anteriormente se usan en la sintaxis clásica de makefile.
Ahora considere cómo instalar GRUB en una partición:
Mkdir -p tempdir # crea un directorio temporal mount / dev / loop2 tempdir # monta la partición en el directorio mkdir tempdir / boot # crea el directorio / boot en la sección cp -r grub tempdir / boot / # copia la carpeta grub en / boot cp kernel.bin tempdir / # copia el kernel en la raíz de la partición de suspensión 1 # espera Ubuntu umount / dev / loop2 # desmonta la carpeta temporal rm -r tempdir # elimina la carpeta temporal losetup -d / dev / loop2 # desmonta la partición
Después de ejecutar los comandos anteriores, la imagen estará lista para instalar GRUB’a. El siguiente comando instala GRUB en el MBR de la imagen de disco hdd.img.
Eco "dispositivo (hd0) hdd.img n root (hd0,0) n setup (hd0) n quitn" | grub - lote 1\u003e / dev / null
¡Todo está listo para probar!
Paso 6. Lanzamiento:
Para compilar, use el comando:
Hacer todo
Después de lo cual debería aparecer el archivo kernel.bin.
Para crear una imagen de disco de arranque, use el comando:
Sudo hacer imagen
Como resultado, debería aparecer el archivo hdd.img.
Ahora puede arrancar desde la imagen de disco hdd.img. Puede verificar esto con el siguiente comando:
Qemu -hda hdd.img -m 32
Qemu-system-i386 -hda hdd.img
Para verificar una máquina real, debe hacer dd de esta imagen en una unidad flash y arrancar desde ella. Por ejemplo, con este comando:
Sudo dd if \u003d. / Hdd.img of \u003d / dev / sdb
En resumen, podemos decir que, como resultado de las acciones tomadas, obtenemos un conjunto de fuentes y scripts que nos permiten realizar varios experimentos en el campo de la programación de sistemas. El primer paso se ha dado hacia la creación de software de sistema como hipervisores y sistemas operativos.
