El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Consideracions de Seguretat

Següent ►
►

En aquest tema, explorarem les millors pràctiques i tècniques per assegurar que el teu codi Ada sigui segur i robust contra vulnerabilitats. La seguretat en el desenvolupament de programari és crucial per protegir les dades i assegurar la integritat dels sistemes.

Conceptes Clau

  1. Validació d'Entrades

    • Assegura't que totes les dades d'entrada siguin validades abans de ser processades.
    • Utilitza tipus forts i subtipus per restringir els valors d'entrada.

  2. Gestió d'Errors i Excepcions

    • Implementa una gestió d'excepcions robusta per manejar errors inesperats.
    • Evita la revelació d'informació sensible en missatges d'error.

  3. Control d'Accés

    • Defineix clarament els permisos i les restriccions d'accés a diferents parts del sistema.
    • Utilitza tipus privats i paquets privats per encapsular dades sensibles.

  4. Protecció de la Memòria

    • Evita l'ús de punteres no inicialitzades o fora de límits.
    • Utilitza mecanismes de protecció de la memòria per prevenir desbordaments de memòria.

  5. Concurrència Segura

    • Assegura't que les tasques concurrents no interfereixin entre elles de manera insegura.
    • Utilitza objectes protegits per sincronitzar l'accés a recursos compartits.

Validació d'Entrades

Exemple de Validació d'Entrades

subtype Positive_Integer is Integer range 1 .. Integer'Last;

procedure Process_Input(Value : in Positive_Integer) is
begin
   -- Processar el valor
   Put_Line("Valor vàlid: " & Integer'Image(Value));
end Process_Input;

procedure Main is
   Input_Value : Integer;
begin
   Put("Introdueix un valor positiu: ");
   Get(Input_Value);
   if Input_Value in Positive_Integer then
      Process_Input(Input_Value);
   else
      Put_Line("Error: Valor no vàlid.");
   end if;
end Main;

Explicació

  • Positive_Integer: Defineix un subtipo que només permet valors positius.
  • Process_Input: Procediment que processa només valors positius.
  • Main: Valida l'entrada abans de cridar el procediment.

Gestió d'Errors i Excepcions

Exemple de Gestió d'Excepcions

procedure Safe_Division(X, Y : in Integer) is
   Result : Integer;
begin
   Result := X / Y;
   Put_Line("Resultat: " & Integer'Image(Result));
exception
   when Constraint_Error =>
      Put_Line("Error: Divisió per zero.");
end Safe_Division;

procedure Main is
begin
   Safe_Division(10, 0);
end Main;

Explicació

  • Safe_Division: Procediment que maneja l'excepció de divisió per zero.
  • Main: Crida el procediment amb un divisor zero per demostrar la gestió d'excepcions.

Control d'Accés

Exemple de Control d'Accés amb Tipus Privats

package Secure_Package is
   type Secure_Data is private;
   procedure Set_Data(D : in out Secure_Data; Value : in Integer);
   function Get_Data(D : in Secure_Data) return Integer;
private
   type Secure_Data is record
      Value : Integer;
   end record;
end Secure_Package;

package body Secure_Package is
   procedure Set_Data(D : in out Secure_Data; Value : in Integer) is
   begin
      D.Value := Value;
   end Set_Data;

   function Get_Data(D : in Secure_Data) return Integer is
   begin
      return D.Value;
   end Get_Data;
end Secure_Package;

with Secure_Package; use Secure_Package;

procedure Main is
   Data : Secure_Data;
begin
   Set_Data(Data, 42);
   Put_Line("Dada segura: " & Integer'Image(Get_Data(Data)));
end Main;

Explicació

  • Secure_Package: Defineix un tipus privat per encapsular dades sensibles.
  • Set_Data i Get_Data: Procediments per accedir i modificar les dades encapsulades.
  • Main: Utilitza el paquet segur per establir i obtenir dades.

Protecció de la Memòria

Exemple de Protecció de la Memòria

procedure Safe_Array_Access is
   type Int_Array is array (1 .. 10) of Integer;
   A : Int_Array := (others => 0);
begin
   for I in 1 .. 10 loop
      A(I) := I;
   end loop;
   Put_Line("Accés segur a l'array completat.");
exception
   when Constraint_Error =>
      Put_Line("Error: Accés fora de límits.");
end Safe_Array_Access;

procedure Main is
begin
   Safe_Array_Access;
end Main;

Explicació

  • Safe_Array_Access: Procediment que assegura l'accés segur a un array.
  • Main: Crida el procediment per demostrar la protecció de la memòria.

Concurrència Segura

Exemple de Concurrència Segura

protected type Shared_Counter is
   procedure Increment;
   function Get_Value return Integer;
private
   Counter : Integer := 0;
end Shared_Counter;

protected body Shared_Counter is
   procedure Increment is
   begin
      Counter := Counter + 1;
   end Increment;

   function Get_Value return Integer is
   begin
      return Counter;
   end Get_Value;
end Shared_Counter;

procedure Main is
   Counter : Shared_Counter;
begin
   Counter.Increment;
   Put_Line("Valor del comptador: " & Integer'Image(Counter.Get_Value));
end Main;

Explicació

  • Shared_Counter: Objecte protegit que permet l'accés segur a un comptador compartit.
  • Main: Utilitza l'objecte protegit per incrementar i obtenir el valor del comptador.

Resum

En aquesta secció, hem explorat diverses tècniques per assegurar el teu codi Ada:

  • Validació d'entrades per prevenir dades no vàlides.
  • Gestió d'errors i excepcions per manejar situacions inesperades.
  • Control d'accés per protegir dades sensibles.
  • Protecció de la memòria per evitar errors de memòria.
  • Concurrència segura per sincronitzar l'accés a recursos compartits.

Aquestes pràctiques són essencials per desenvolupar aplicacions segures i robustes en Ada. En el següent tema, explorarem com construir un projecte complet en Ada, aplicant les tècniques i conceptes apresos fins ara.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats