Joven hacker sonriendo

Hackeamos su software

cero falsos positivos

Inteligencia experta + Tecnología especializada
DXST - SAST - IAST - SCA - DevSecOps
Caja blanca - Caja gris - Caja negra
Atacando Aplicaciones Web, APIs, Apps Móviles,
Cliente Servidor, Servidores, Redes, Dispositivos IoT
IoT SCI: Sistemas de Control Industrial

Registrar Excepciones ILE

Nuestros ethical hackers explican cómo evitar vulnerabilidades de seguridad mediante la programación segura en COBOL al registrar excepciones ILE. Esto es particularmente útil a la hora de compilar objetos tipo CBLLE, y para registrar y clasificar eventos excepcionales por severidad y ocurrencia.

Necesidad

Registrar excepciones en bitácoras usando punteros en ILE COBOL.

Contexto

A continuación se describe las circunstancias bajo las cuales la siguiente solución tiene sentido:

  1. Se está desarrollando una aplicación en COBOL.

  2. El tipo de objeto a compilar es CBLLE.

  3. Los eventos excepcionales deben ser registrados en bitácoras[1].

  4. Los eventos excepcionales deben clasificarse por severidad[2].

  5. Los eventos deben contener el momento de ocurrencia (fecha, hora, segundos, mili-segundos y zona horaria)[3].

Solución

En la siguiente solución, CBLERR2 causará el error y ERRHDL2 se encargará de atrapar la excepción, además de guardar la fecha de ocurrencia exacta, el nombre del miembro y la biblioteca, y el ID de la excepción.

  • CBLERR2

    1. Este programa registra un controlador de excepciones para ILE COBOL. Luego de registrar exitosamente el controlador, dicho programa genera el error "data decimal". Dicha excepción causa que el controlador llame al programa definido en su argumento (ERRHDL2).

    2. Se da inicio al programa definiendo la división IDENTIFICATION DIVISION. La palabra clave NOMONOPRC sirve para indicarle al compilador que los nombres serán tratados con case-sensitive:

      cblerr2.cbl
      1
      2
      3
      4
      5
      6
             PROCESS NOMONOPRC.
             IDENTIFICATION DIVISION.
            ******************
            * Identification *
            ******************
             PROGRAM-ID. CBLERR2.
      
    3. En la división ENVIRONMENT DIVISION se enlaza el programa con la interfaz de programación QInSetCobolErrorHandler[4]:

      1
      2
      3
      4
      5
      6
      7
      8
      9
            ***************
            * Environment *
            ***************
             ENVIRONMENT DIVISION.
             CONFIGURATION SECTION.
               SOURCE-COMPUTER. IBM-ISERIES.
               OBJECT-COMPUTER. IBM-ISERIES.
               SPECIAL-NAMES.
               LINKAGE TYPE PROCEDURE FOR "QlnSetCobolErrorHandler".
      
    4. En la división DATA DIVISON se define los datos con los que trabajaremos:

       1
       2
       3
       4
       5
       6
       7
       8
       9
      10
      11
            ********
            * Data *
            ********
             DATA DIVISION.
             WORKING-STORAGE SECTION.
             01  MISC.
                 05  Y               PIC S9(09) VALUE 0.
             01  ERROR-HANDLER       PROCEDURE-POINTER.
             01  OLD-ERROR-HANDLER   PROCEDURE-POINTER.
             01  NUMERIC-GROUP.
                 05  X               PIC  9(03).
      
    5. Copiamos la estructura de datos para el manejo de errores:

      1
             COPY QUSEC OF QSYSINC-QCBLLESRC.
      
    6. En la división PROCEDURE DIVISION establecemos la lógica de la aplicación:

      1
      2
      3
      4
      5
      6
            ********
            * Main *
            ********
             PROCEDURE DIVISION.
             MAIN.
                 MOVE 16 TO BYTES-PROVIDED OF QUS-EC.
      
    7. Establecemos el controlador de errores apuntando al programa ERRHDL2:

      1
                 SET ERROR-HANDLER TO ENTRY LINKAGE PROGRAM "ERRHDL2".
      
    8. Hacemos un llamado a la interfaz de programación que se encargará de registrar el nuevo controlador de errores:

      1
      2
      3
      4
             CALL "QlnSetCobolErrorHandler"
             USING ERROR-HANDLER,
                   OLD-ERROR-HANDLER,
                   QUS-EC.
      
    9. Causamos la excepción y terminamos el programa:

      1
      2
      3
             ADD X TO Y.
      
             STOP RUN.
      
  • ERRHDL2

    1. Este programa se encarga de recibir la excepción y almacenarla en el archivo LOGGER de la biblioteca actual.

    2. Se da inicio al programa definiendo la división IDENTIFICATION DIVISION:

      errhdl2.cbl
      1
      2
      3
      4
      5
             IDENTIFICATION DIVISION.
            ******************
            * Identification *
            ******************
             PROGRAM-ID. ERRHDL2.
      
    3. En la división ENVIRONMENT DIVISION declaramos el uso del archivo LOGGER:

      1
      2
      3
      4
      5
      6
      7
      8
      9
            ***************
            * Environment *
            ***************
             ENVIRONMENT DIVISION.
             INPUT-OUTPUT SECTION.
             FILE-CONTROL.
                 SELECT LOG-FILE ASSIGN TO 'LOGGER'
                 ORGANIZATION IS SEQUENTIAL
                 FILE STATUS IS LOG-STATUS.
      
    4. Se define la división DATA DIVISION:

      1
      2
      3
      4
            ********
            * Data *
            ********
             DATA DIVISION.
      
    5. En la sección de archivo establecemos el formato para la línea que se almacenará en la bitácora:

      1
      DDDDDDDDDDDDDDDDDDDDDPPPPPPPPPPPPPPPPPPPPIIIIIIIIII
      
    6. De la siguiente manera:

      1
      2
      3
      4
      5
      6
             FILE SECTION.
             FD LOG-FILE.
             01 LOG-RECORD.
                 05 LOG-DATE         PIC X(21).
                 05 LOG-PGM-IN-ERROR PIC X(20).
                 05 LOG-EXCEPTION-ID PIC X(10).
      
    7. En la sección LINKAGE SECTION definimos las variables que el programa aceptará como argumento:

       1
       2
       3
       4
       5
       6
       7
       8
       9
      10
      11
      12
             LINKAGE SECTION.
             01 CBL-EXCEPTION-ID     PIC  X(07).
             01 VALID-RESPONSES      PIC  X(06).
             01 PGM-IN-ERROR.
                 05 PGM-NAME         PIC  X(10).
                 05 LIB-NAME         PIC  X(10).
             01 SYS-EXCEPTION-ID     PIC  X(07).
             01 MESSAGE-TEXT         PIC  X(01).
             01 MESSAGE-LENGTH       PIC S9(09) BINARY.
             01 SYS-OPTION           PIC  X(01).
             01 ERR-MODULE-NAME      PIC  X(10).
             01 CBL-PGM-NAME         PIC X(256).
      
    8. En la sección WORKING-STORAGE SECTION definimos las variables para el manejo de fechas y errores en el archivo de registro:

      1
      2
      3
             WORKING-STORAGE SECTION.
             01 WS-CURRENT-DATE      PIC X(21).
             01 LOG-STATUS           PIC 99.
      
    9. En la división PROCEDURE DIVISION se encuentra la lógica del programa. Esta división acepta varios argumentos, entre ellos el programa que generó la excepción, el ID y descripción de la excepción, entre otros:

       1
       2
       3
       4
       5
       6
       7
       8
       9
      10
      11
      12
      13
            ********
            * Main *
            ********
             PROCEDURE DIVISION USING CBL-EXCEPTION-ID,
                                      VALID-RESPONSES,
                                      PGM-IN-ERROR,
                                      SYS-EXCEPTION-ID,
                                      MESSAGE-LENGTH,
                                      SYS-OPTION,
                                      MESSAGE-TEXT,
                                      ERR-MODULE-NAME,
                                      CBL-PGM-NAME.
             MAIN.
      
    10. Abrimos el archivo en modo extendido:

      1
                 OPEN EXTEND LOG-FILE.
      
    11. Obtenemos la fecha exacta (con milisegundos), en la cual ser generó la excepción:

      1
             MOVE FUNCTION CURRENT-DATE TO WS-CURRENT-DATE.
      
    12. Construimos el registro:

      1
      2
      3
             MOVE WS-CURRENT-DATE  TO LOG-DATE.
             MOVE PGM-IN-ERROR     TO LOG-PGM-IN-ERROR.
             MOVE SYS-EXCEPTION-ID TO LOG-EXCEPTION-ID.
      
    13. Escribimos el registro en la bitácora:

      1
             WRITE LOG-RECORD.
      
    14. Cerramos el archivo para usos posteriores:

      1
                 CLOSE LOG-FILE.
      
    15. Enviamos la opción C para que el programa continúe:

      1
      2
                 MOVE "C" TO SYS-OPTION.
                 STOP RUN.
      
    16. El archivo LOGGER luego de varias pruebas podrá tener el registro exacto de la excepción, como se puede observar en el siguiente ejemplo:

      1
      2
      3
      4
      5
      DDDDDDDDDDDDDDDDDDDDDPPPPPPPPPPPPPPPPPPPPIIIIIIIIII
      2012052818325404-0500CBLERR2   Fluid-Attacks     MCH1202
      2012052818335975-0500CBLERR2   Fluid-Attacks     MCH1202
      2012052818573501-0500CBLERR2   Fluid-Attacks     MCH1202
      2012052818573677-0500CBLERR2   Fluid-Attacks     MCH1202
      

Descargas

Puedes descargar el código fuente pulsando en los siguientes enlaces:

  1. cblerr2.cbl contiene el código que genera el error y que es capturado por errhdl2.

  2. errhdl2.cbl contiene las instrucciones para capturar y procesar el error generado desde cblerr2.




Haz un comentario

Estado de los servicios - Términos de Uso