Joven hacker sonriendo

Hackeamos su software

cero falsos positivos

Atacando Aplicaciones, APIs, Apps Móviles, Servidores Redes, Dispositivos IoT
SCI: Sistemas de Control Industrial
COS: Centro de Operaciones de Seguridad

Registrar Excepciones OPM

Nuestros ethical hackers explican cómo evitar vulnerabilidades de seguridad mediante la programación segura en COBOL al realizar un manejo adecuado de excepciones. Las excepciones se pueden presentar debido a errores durante la ejecución del programa y deben registrarse en bitácoras.

Necesidad

Registrar excepciones en bitácoras a través del uso del API OPM en COBOL sin usar punteros.

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 CBL.

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

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

Solución

En la siguiente solución, CBLERR1 causará el error y ERRHDL1 se encargará de atrapar la excepción, a través del uso de la interfaz de programación QPDLOGER[3].

  • CBLERR1

    1. Este programa registra un controlador de excepciones para OPM 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 (ERRHDL1).

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

      cblerr1.cbl
      1
      2
      3
      4
      5
             IDENTIFICATION DIVISION.
            ******************
            * Identification *
            ******************
             PROGRAM-ID. CBLERR1.
      
    3. En la división DATA DIVISION se declaran las variables:

       1
       2
       3
       4
       5
       6
       7
       8
       9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
            ********
            * Data *
            ********
             DATA DIVISION.
      
             WORKING-STORAGE SECTION.
             01 MISC.
                 05 ERROR-HANDLER       PIC  X(20).
                     06 OBJECT-NAME     PIC  X(10) VALUE "ERRHDL1".
                     06 LIBRARY-NAME    PIC  X(10) VALUE "Fluid Attacks".
                 05 SCOPE               PIC  X(01) VALUE "C".
                 05 ERROR-HANDLER-LIB   PIC  X(10) VALUE "".
                 05 PRIOR-ERROR-HANDLER PIC  X(20).
      
             01 NUMERIC-GROUP.
                 05 X PIC 9(03).
                 05 Y PIC S9(09) VALUE 0.
      
             01 WS-ERROR-HANDLER.
                 02 BYTES-PROVIDED   PIC S9(009) BINARY.
                 02 BYTES-AVAILABLE  PIC S9(009) BINARY.
                 02 EXCEPTION-ID     PIC  X(007).
                 02 RESERVED         PIC  X(001).
                 02 EXCEPTION-DATA   PIC  X(240).
      

      Del anterior bloque de código identificamos tres estructuras de datos: MISC: contiene información acerca del programa que controlará la excepción. NUMERIC-GROUP: contiene las variables que generarán la excepción. ** WS-ERROR-HANDLER: estructura de datos donde se almacena la información en caso de ocurrencia de error al momento de llamar a la interfaz de programación QLRSETCE[4].

    4. En la división PROCEDURE DIVISION se establece el flujo principal:

      1
      2
      3
      4
      5
            ********
            * Main *
            ********
             PROCEDURE DIVISION.
             MAIN.
      
    5. Se inicializa el parámetro de código de error:

      1
             MOVE 16 TO BYTES-PROVIDED OF WS-ERROR-HANDLER.
      
    6. Se llama a la interfaz de programación QLRSETCE, la cual registra el punto de salida en caso de excepción (en este caso se llamará el programa ERRHDL1):

      1
      2
      3
      4
      5
      6
             CALL "QLRSETCE"
             USING ERROR-HANDLER OF MISC,
                   SCOPE OF MISC,
                   ERROR-HANDLER-LIB   OF MISC,
                   PRIOR-ERROR-HANDLER OF MISC,
                   WS-ERROR-HANDLER.
      
    7. Si ocurre una excepción al llamar la interfaz de programación, se muestra los detalles del error y se detiene la ejecución del programa:

      1
      2
      3
      4
             IF BYTES-AVAILABLE OF WS-ERROR-HANDLER > 0
                 DISPLAY "Error setting handler"
                 STOP RUN
             END-IF.
      
    8. En este punto ocurre la excepción (se desea sumar el contenido de la variable X, pero está inicializada en blanco):

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

    1. Este programa es el encargado de recibir las excepciones y posteriormente registrarlas a través de la interfaz de programación QPDLOGER.

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

      errhdl1.cbl
      1
      2
      3
      4
      5
             IDENTIFICATION DIVISION.
            ******************
            * Identification *
            ******************
             PROGRAM-ID. ERRHDL1.
      
    3. La división DATA DIVISION contiene cuatro estructuras:

       1
       2
       3
       4
       5
       6
       7
       8
       9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
            ********
            * Data *
            ********
             DATA DIVISION.
      
             WORKING-STORAGE SECTION.
             01 MISC.
                 05 LOG-EXCEPTION-ID PIC  X(12).
                 05 MESSAGE-KEY      PIC  X(04).
                 05 POINT-OF-FAILURE PIC S9(09) BINARY VALUE 1.
                 05 PRINT-JOBLOG     PIC  X(01) VALUE "Y".
                 05 NBR-OF-ENTRIES   PIC S9(09) BINARY.
                 05 NBR-OF-OBJECTS   PIC S9(09) BINARY VALUE 1.
      
             01 MESSAGE-INFO.
                 05 MSG-OFFSET       PIC S9(09) BINARY.
                 05 MSG-LENGTH       PIC S9(09) BINARY.
      
             01 OBJECT-LIST.
                 05 OBJECT-NAME      PIC  X(30).
                 05 LIBRARY-NAME     PIC  X(30).
                 05 OBJECT-TYPE      PIC  X(10) VALUE "*PGM      ".
      
             01 WS-ERROR-HANDLER.
                 02 BYTES-PROVIDED   PIC S9(009) BINARY.
                 02 BYTES-AVAILABLE  PIC S9(009) BINARY.
                 02 EXCEPTION-ID     PIC  X(007).
                 02 RESERVED         PIC  X(001).
                 02 EXCEPTION-DATA   PIC  X(240).
      
      • MISC: contiene información variada del programa.

      • MESSAGE-INFO: es el mensaje de excepción.

      • OBJECT-LIST: contiene datos generales del objeto que causó la excepción, tales como nombre y tipo del objeto, y el nombre de la biblioteca.

      • WS-ERROR-HANDLER: estructura de datos donde se almacena la información en caso de ocurrencia de error al momento de llamar a la interfaz de programación QPDLOGER.

    4. La sección LINKAGE SECTION contiene las variables que el programa aceptará como argumento:

       1
       2
       3
       4
       5
       6
       7
       8
       9
      10
             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).
      
    5. 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
            ********
            * Main *
            ********
             PROCEDURE DIVISION USING CBL-EXCEPTION-ID,
                                      VALID-RESPONSES,
                                      PGM-IN-ERROR,
                                      SYS-EXCEPTION-ID,
                                      MESSAGE-TEXT,
                                      MESSAGE-LENGTH,
                                      SYS-OPTION.
      
             MAIN.
      
    6. Se inicializa los parámetros de código de error:

      1
      2
             MOVE 16 TO BYTES-PROVIDED OF WS-ERROR-HANDLER.
             MOVE SYS-EXCEPTION-ID TO LOG-EXCEPTION-ID.
      
    7. Se inicializa las variables de uso general de acuerdo a la longitud del mensaje recibido en el argumento:

      1
      2
      3
      4
      5
      6
      7
      8
      9
             IF MESSAGE-LENGTH > 0
                 MOVE 1 TO MSG-OFFSET,
                 MOVE MESSAGE-LENGTH TO MSG-LENGTH,
                 MOVE 1 TO NBR-OF-ENTRIES,
             ELSE
                 MOVE 0 TO MSG-OFFSET,
                 MOVE 0 TO MSG-LENGTH,
                 MOVE 0 TO NBR-OF-ENTRIES
             END-IF.
      
    8. Movemos el nombre del objeto y la biblioteca a la estructura de datos OBJECT-LIST:

      1
      2
             MOVE PGM-NAME TO OBJECT-NAME.
             MOVE LIB-NAME TO LIBRARY-NAME.
      
    9. La interfaz de programación QPDLOGER, permite a un programa reportar un problema de software al servidor local y proveer la suficiente información para solucionarlo. Cuando la interfaz es llamada, cualquier error es enviado a uno o más spooled files, una cadena del síntoma que generó el error es creada, una entrada es creada en el registro de problemas, y un mensaje es enviado a la cola de mensajes QSYSOPR, indicando que un error de software ha sido detectado:

       1
       2
       3
       4
       5
       6
       7
       8
       9
      10
      11
             CALL "QPDLOGER" USING PGM-NAME,
                                   LOG-EXCEPTION-ID,
                                   MESSAGE-KEY,
                                   POINT-OF-FAILURE,
                                   PRINT-JOBLOG,
                                   MESSAGE-TEXT,
                                   MESSAGE-INFO,
                                   NBR-OF-ENTRIES,
                                   OBJECT-LIST,
                                   NBR-OF-OBJECTS,
                                   WS-ERROR-HANDLER.
      
    10. En caso de ocurrencia de error mostramos el mensaje pertinente:

      1
      2
      3
             IF BYTES-AVAILABLE OF WS-ERROR-HANDLER > 0
                 DISPLAY "Error en el llamado a la interfaz QPDLOGER"
             END-IF.
      
    11. Finalizamos el programa:

      1
      2
             MOVE "C" TO SYS-OPTION.
             STOP RUN.
      

Descargas

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

  1. cblerr1.cbl contiene el código que genera el error y que es capturado por errhdl1.

  2. errhdl1.cbl contiene las instrucciones para capturar y procesar el error generado desde cblerr1.




Haz un comentario

Estado de los servicios - Términos de Uso