Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Temas - Olger346

Páginas: [1]
1
Buenas, ¿qué tal comunidad?

Tengo una duda, ya que estoy analizando un programa de Python y me he perdido en la secuencia en la ejecución del mismo por la gran cantidad de archivos que tiene y la gran cantidad de código.

Hay alguna forma de interpretarlo paso a paso? como en algún debugger. Nótese que no es un exe.

Gracias por leer.

2
Hacking / HTML Injection (post para novatos)
« en: Diciembre 25, 2017, 10:05:50 am »
Felíz Navidad a todos...

Hoy vengo a postear sobre lo que dice el título. Bien tal vez será que no lo veamos mucho en las webs de internet. Pero sigue siendo una de las vulnerabilidades que lleva mucho años en el top 10 de OWASP, y se da en parte porque obviamos algunas cosas o porque pensamos que nadie vendrá a atacarnos porque no tenemos nada importante. Sin embargo, no está dentro de las mejores prácticas en la gobernanza de activos de TI.

Qué es html injection (OWASP)
Citar
HTML injection is a type of injection issue that occurs when a user is able to control an input point and is able to inject arbitrary HTML code into a vulnerable web page. This vulnerability can have many consequences, like disclosure of a user's session cookies that could be used to impersonate the victim, or, more generally, it can allow the attacker to modify the page content seen by the victims.

Bien según owasp tenemos multiples variantes a insertar en una web vulnerable. Para efecto de prueba y ética usare bWAPP.
Ejemplo 1: Nivel bajo (validación de entrada de datos nula)


En este caso la validación de la entrada de los caracteres es nula y por ello se ve reflejada en la salida del navegador y por ello, los caracteres "<" ">" son tratados como una cosa normal ante el sitio y el navegador.


Hemos intentado insertando un script para mandar una alerta al usuario (esto sólo pasa si enviamos la url maliciosa a un usuario específico).

Ejemplo 2: Nivel medio (aquí es donde viene lo bueno del asunto). Cuando el programador cree que es más listo que el atacante.

Para explicar exactamente qué es lo que sucede, es que el programador ha decidido anular los caracteres "<" ">" que son indispensables para la inyección de código de html y javascript. Sin embargo sabemos que nuestra aplicación utiliza PHP como su lenguaje de backend y esta siendo procesado por el servidor. Si nos fijamos en la URL del navegador tenemos múltiples caracteres que aparecen dentro de ellos "%" y otros caracteres que son interpretados por PHP y que darán respuesta al navegador. Muy característicos de CMS como Joomla y Drupal que funcional bajo php

¿Entonces qué podemos hacer? Utilizaremos esta información que nos brinda la URL, bajo http://www.degraeve.com/reference/urlencoding.php esta tabla podemos convertir cualquier caracter normal a uno que interprete el servidor.

Código: [Seleccionar]
%3Cinput type="text" name="usuario"%3E
%3Cinput type="password" name="passwd"
Con esto bypaseamos las buenas intenciones del programador.

Bien, esta entrada de datos la podemos enviar a otro servidor y recojerlas y habremos obtenido un usuario y password que seguramente algún flojo no cambió en sus redes sociales. Claro que debe ser un poquito más de codificación en HTML

Ejemplo 3: Nivel Difícil
En este nivel vemos la mejor manera de evitar que un atacante intente insertar código en nuestra web.

Esta vez vemos que no podemos usar ninguna de las formas que intentamos anteriormente. Esto se debe a que el programador utilizó una función de PHP que nos ha mandado a "tomar por saco".

Sin embargo aquí no se queda todo, la función utilizada por el programador fue htmlentities(). Por sí sola esta función no para que los atacantes inserten código en el navegador.
Código: [Seleccionar]
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">Acompañada de la codificación que acepte el navegador esta función puede o no ser útil. En este caso el programador decidió que UTF-8 sería la entrada aceptada, de manera que no podemos bypasear la función utilizando UTF-7 u otro.

Si el programador hubiese puesto un documento normal de HTML probablemente seguiría siendo vulnerable el sitio.
por ejemplo:
Código: [Seleccionar]
<html> 
<body>
<input type="text" name="username" action="">
<input type="password" name="passwd">
<button type="submit" name="boton" value="Log in">
</body></html>
El código sería vulnerable porque no se ha especificado el valor de la codificación en el tag <meta> en la página.

Referencias
http://www.degraeve.com/reference/urlencoding.php
https://www.exploit-db.com/docs/english/42609-code-injection-%E2%80%93-html-injection.pdf
https://www.exploit-db.com/papers/13646/

Espero que les haya servido. :)


3
Dudas y pedidos generales / [SOLUCIONADO] bWAPP PHP code Injection
« en: Noviembre 06, 2017, 01:48:08 pm »
Buenas a todos. Hace muuuucho tiempo que no posteo nada.
Hoy decidí practicar nuevamente con la aplicación bwapp de owasp. En el nivel intermedio tenemos algo curioso en la aplicación y es que ahora acepta caracteres especiales que dificultan la ejecición de codigo en funciones como exec, shell_exec, que en el nivel simple se dan muy bien...


Mi duda... ¿Cómo puedo bypasear esta sentencia de código?
Código: [Seleccionar]
<?php

if(isset($_REQUEST["message"]))
{

    
// If the security level is not MEDIUM or HIGH
    
if($_COOKIE["security_level"] != "1" && $_COOKIE["security_level"] != "2")
    {

?>

    <p><i><?php @eval ("echo " $_REQUEST["message"] . ";");?></i></p>

<?php

    
}

    
// If the security level is MEDIUM or HIGH
    
else
    {
?>

    <p><i><?php echo htmlspecialchars($_REQUEST["message"], ENT_QUOTES"UTF-8");;?></i></p>

<?php

    
}

}

?>

Estuve sviendo algunos videos acerca de esta función y por lo que he comprendido anula las comillas simples y dobles, sin embargo el ampersant && la app cambia su comportamiento, todo lo que va despues del & queda ignorado a la vista del navegador.

4
Hola muchachos tengo una pequeña duda acerca de este fragmento de código que he programado en un juego que se llama Checkio.

El enunciado es el siguiente
 
Citar
"Fizz buzz" es un juego con palabras que usaremos para enseñarles a los robots acerca de la división. Aprendamos de computadoras.
Tú deberías escribir una función que recibirá un entero positivo y devolver: "Fizz Buzz" si el número es divisible por 3 y por 5;
"Fizz" si el número es divisible por 3;
"Buzz" si el número es divisible por 5;
El número como una cadena para los otros casos.
Entrada: Un número como un entero.
Salida: La respuesta como una cadena de caracteres.
Precondición: 0 < número ≤ 1000

Entonces en el intérprete pongo el siguiente fragmento de código
Código: Python
  1. def checkio(number):
  2.    if(0< number and number<100):
  3.        if(number%3=0):
  4.            print "Fizz Buzz"
  5.        else:
  6.            print "No es divisible por 3"
  7.        if(number%5=0)
  8.             print"Buzz"
  9.     return str(number)
  10.  
  11. number = input("Introduzca un entero")
  12. checkio(number)
  13. print "el numero es divisible entre alguno de los dos" + number
  14.  
Me esta marcando error en las líneas 3 y 7 y la verdad no comprendo el por qué. O si estoy obviando algo por favor díganmelo tiendo a confundir estas sentencias con las de C. Les agradezco por la ayuda que me puedan brindar

5
ASM / Suma y Resta + Flags (registro de estado) [INTEL 8086]
« en: Julio 07, 2015, 01:01:28 am »
El objetivo de este programa es notar la variación de las banderas después de ejecutar una operación aritmetica, en este caso suma y resta.
Espero haber documentado bien el código para que todo haya quedado claro, también quiero decir que la rutina de scanum la saque de un sitio brujo, pero podeís observar que hace emulando paso por paso.

Las variables se almacenan en el registro cx, el cual hay que moverselo a una variable, de lo contrario se pierde el valor de la variable.
El programa solo corre en un rango de -128 a 127.
Hay algunas banderas que probablemente no cambiaran.

Espero que sea de utilidad. ^w^b
Código: ASM
  1. imprime_car macro   car
  2.    
  3.     mov    ah,10
  4.     mov    al,car
  5.     mov    bh,0
  6.     mov    cx,1
  7.     int    10h      
  8.  
  9. endm
  10.  
  11. print  macro cad
  12.     mov   ah,9
  13.     lea   dx,cad
  14.     int   21h
  15.    
  16. endm    
  17.  
  18. getch macro dato
  19.    
  20.     mov  ah,0   ; servicio 0 de Teclado
  21.     int  16h    ; Interrupcion de teclado
  22.    
  23.     mov  dato,al
  24.    
  25. endm
  26.  
  27. cursor_xy  macro X,Y
  28.    
  29.     mov    ah,2     ; servicio 2 de video
  30.     mov    dh,Y     ; coordenada de la fila
  31.     mov    dl,X     ; coordenada de la columna
  32.     mov    bh,0    
  33.     int    10h      ; interrupcion de video
  34.    
  35. endm
  36.  
  37. putc macro   car
  38.    
  39.     mov    ah,10
  40.     mov    al,car
  41.     mov    bh,0
  42.     mov    cx,1
  43.     int    10h
  44. endm  
  45.  
  46. getint macro dato       ;modificaciones de la macro getch
  47.    
  48.     mov  ah,0   ; servicio 0 de Teclado
  49.     int  16h    ; Interrupcion de teclado
  50.    
  51.     mov  dato,ax ;cambiar a ax para recojer datos de 2bytes osea mayores a 127
  52.    
  53. endm
  54.  
  55. .data
  56.   error db "error",13,10,36
  57.   h1 db "                                                      ",13,10,
  58.      db "                  Registro de Estado          Olger346",13,10,
  59.      db "              Operaciones con Negativos               ",13,10,
  60.      db "                      + Suma                    11R122",13,10,
  61.      db "                      - Resta                         ",13,10,
  62.      db "                      ESC                             ",13,10,36
  63.          
  64.   h2 db "                 Valor de A (127-128)                 ",13,10,36
  65.   h3 db "                 Valor de B (127-128)                 ",13,10,36
  66.      
  67.   h4 db "       - - - - O D I T S Z - A - P - C                ",13,10,
  68.      db "                                                      ",13,10,
  69.      db "                                                      ",13,10,
  70.      db " Aritmeticos & Logicos   Control                      ",13,10,
  71.      db " Acarreo         =       Direccion    =                    ",13,10,
  72.      db " Paridad         =       Interrupcion =           Valor    ",13,10,
  73.      db " Auxiliar        =       Trazado      =           A=       ",13,10,
  74.      db " Cero            =                                B=       ",13,10,
  75.      db " Signo           =                         resultado       ",13,10,
  76.      db " Desbordamiento  =                                         ",13,10,36
  77.                                                                      
  78.    B db "  ",36 ;variable xa impresion hexadecimal y otras
  79.    A dw ?       ;1er valor a introducir
  80.    C dw ?       ;segundo valor a introducir
  81.    G db ?  
  82.    M dw ?       ;resultado de suma o resta
  83.    I dw ?       ;recoje un caracter ya sea +-
  84.    X db 40  ;variable de barrido de impresion
  85.                                                     make_minus db ?
  86.  ten dw 10
  87.  msg db    0,25,36
  88.  K   db 16
  89.  bla db "   ",36
  90.              ;variables de control de ciclo
  91.  U   db 40
  92.  V   db 40
  93.  W   db 37
  94. flag dw ?      ;variable para almacenar el registro de estado
  95.  ntr db "0",36  
  96.  control db 40  
  97.  ecchi db 40
  98.  
  99.    
  100. .stack
  101.    
  102. .code
  103.        
  104.     mov ax,@data
  105.     mov ds,ax  
  106.        
  107.     cursor_xy 0,1      
  108.     print h1        
  109.     cursor_xy 26,6  ;coloca cursor en el primer ingreso del signo aritmetico
  110.    
  111.    
  112. ciclo:    
  113.    
  114.     mov I,0
  115.     cursor_xy 26,6
  116.     print bla
  117.     cursor_xy 26,6
  118.     getint  I
  119.     mov ax,I
  120.     mov B,al ;se imprime  
  121.     print B    
  122.    
  123.     cmp I,4E2Bh    ;podeis cambiar esto a 1 y funcionara con el 1 del teclado
  124.     je  suma
  125.    
  126.     cmp I, 4A2Dh   ;igual podeis cambiar a 2
  127.     je  resta
  128.    
  129.     cmp I,01
  130.     je  final
  131.    
  132.     print error
  133.     jmp ciclo
  134.    
  135.     ;call SCAN_NUM   ;scanea el signo aritmetico    
  136.     ;mov     G,cx      
  137.    
  138.    
  139. suma:
  140.      
  141.     mov cx,0        ; en cx queda un valor hay que resetearlo para que no haya basura en el valor que se vuelve a introducir nuevamente
  142.     mov A,0         ;limpiamos el valor que tenia la variable A
  143.     cursor_xy 0,7  
  144.     print h2
  145.     cursor_xy 38,7  ;coloca cursor en el primer ingreso del primer valor
  146.     call SCAN_NUM   ;scanea el primer valor
  147.     mov     A,cx    
  148.    
  149.     cmp   A,128
  150.     je    suma
  151.    
  152.     cmp   A,-129
  153.     je    suma
  154.    
  155.     mov cx,0
  156.     mov C,0
  157.     cursor_xy 0,8
  158.     print h3
  159.     cursor_xy 38,8  ;coloca cursor en el primer ingreso del segund valor
  160.     call SCAN_NUM   ;scanea el segundo valor
  161.     mov     C,cx    
  162.    
  163.     cmp   C,128
  164.     je   suma
  165.    
  166.     cmp   C,-128
  167.     je    suma
  168.    
  169.     mov  ax,A ; mov para sumar
  170.     add  ax,C ; anade a ax lo q tiene c
  171.     mov  M,ax ; mov la suma a la variable M
  172.    
  173.     mov ax,M
  174.     xchg al,ah
  175.     push ax
  176.     call HEXA
  177.        
  178.     cursor_xy 60,22    
  179.     print B   ;imprime la parte high de ax osea M
  180.    
  181.     mov  ax,M
  182.     push ax
  183.     call HEXA
  184.    
  185.    
  186.     cursor_xy 62,22
  187.     print B ;imprime 1byte de la parte low de ax osea M
  188.    
  189.     cursor_xy 0,14
  190.     print h4 ;imprime esquema de flag
  191.    
  192.    
  193.     mov  ax,A ; mov para sumar
  194.     add  ax,C ; anade a ax lo q tiene c
  195.        
  196.     pushf    ; ax=Flag
  197.     pop ax ;pop F para almacenar las flags
  198.    
  199.     cursor_xy 0,16  ;impresion de flags
  200.     mov flag,ax
  201.                              
  202.     jmp binario4
  203.        
  204.    
  205.    
  206.    
  207. resta:  
  208.    
  209.     mov cx,0        ; en cx queda un valor hay que resetearlo para que no haya basura en el valor que se vuelve a introducir nuevamente
  210.     mov A,0         ; limpiamos el valor que habia en A
  211.     cursor_xy 0,7  
  212.     print h2
  213.     cursor_xy 38,7  ;coloca cursor en el primer ingreso del primer valor
  214.     call SCAN_NUM   ;scanea el primer valor
  215.     mov     A,cx  
  216.    
  217.     cmp   A,128
  218.     je   resta
  219.    
  220.     cmp   A,-129
  221.     je    resta
  222.    
  223.     mov cx,0        ; en cx queda un valor hay que resetearlo para que no haya basura en el valor que se vuelve a introducir nuevamente
  224.     mov C,0         ;limpiamos el valor que queda en C
  225.     cursor_xy 0,8
  226.     print h3
  227.     cursor_xy 38,8  ;coloca cursor en el primer ingreso del segund valor
  228.     call SCAN_NUM   ;scanea el segundo valor
  229.     mov     C,cx
  230.    
  231.     cmp   C,128
  232.     je   resta
  233.    
  234.     cmp   C,-129
  235.     je    resta  
  236.    
  237.    
  238.     mov  ax,A       ; mov para sumar
  239.     sub  ax,C       ; anade a ax lo q tiene c
  240.     mov  M,ax       ; mov la suma a la variable M
  241.    
  242.     mov ax,M
  243.     xchg al,ah
  244.     push ax
  245.     call HEXA
  246.     cursor_xy 60,22
  247.     print B         ;imprime la parte high de ax osea M
  248.    
  249.     mov ax,M
  250.     push ax
  251.     call HEXA
  252.     cursor_xy 62,22
  253.     print B         ;imprime 1byte de la parte low de ax osea M
  254.    
  255.    
  256.    
  257.     cursor_xy 0,14
  258.     print h4        ;imprime esquema de flag
  259.    
  260.     mov  ax,A ; mov para sumar
  261.     sub  ax,C ; anade a ax lo q tiene c
  262.        
  263.     pushf    ; ax=Flag
  264.     pop ax ;pop F para almacenar las flags
  265.    
  266.     cursor_xy 0,16  ;impresion de flags
  267.     mov flag,ax
  268.                                        
  269.     jmp binario4
  270.        
  271.    
  272.  
  273. binario1:
  274.        
  275.         mov   ax,A  
  276.                             ;mov   bx,ax
  277.         and   ax,1          ;cambias esto            ; Residuo de dividir entre 2  
  278.        
  279.        
  280.         cursor_xy U,9
  281.         add   al,48     ;suma para que aparezca el caracter en pantalla ascii
  282.         putc  al
  283.        
  284.         sub   U,2       ; y esto para convertir a octal y ya
  285.         shr   A,1
  286.         dec   K                ;sub K,1
  287.          
  288.         cmp U,28        ;barrido para impresion de pantalla
  289.         jae binario1
  290.         add U,14
  291.        
  292.         jmp binario2
  293.        
  294. binario2:
  295.  
  296.         mov   ax,C  
  297.                             ;mov   bx,ax
  298.         and   ax,1          ;cambias esto            ; Residuo de dividir entre 2  
  299.        
  300.        
  301.         cursor_xy V,10
  302.         add   al,48    ;suma para que aparezca el caracter en pantalla ascii
  303.         putc  al
  304.        
  305.         sub   V,2  ; y esto para convertir a octal y ya
  306.         shr   C,1
  307.         dec   K                ;sub K,1
  308.          
  309.         cmp V,28      ;barrido para impresion de pantalla
  310.         jae binario2
  311.         add V,14
  312.         jmp binario3  
  313.        
  314. binario3:
  315.  
  316.          
  317.         mov   ax,M  
  318.                                   ;mov   bx,ax
  319.         and   ax,1          ;cambias esto            ; Residuo de dividir entre 2  
  320.        
  321.        
  322.         cursor_xy X,11
  323.         add   al,48    ;suma para que aparezca el caracter en pantalla ascii
  324.         putc  al
  325.        
  326.         sub   X,2  ; y esto para convertir a octal y ya
  327.         shr   M,1
  328.         dec   K                ;sub K,1
  329.          
  330.         cmp X,28      ;barrido para impresion de pantalla
  331.         jae binario3
  332.         add X,14  
  333.         jmp ciclo
  334.  
  335. binario4:
  336.  
  337.          
  338.         mov   ax,flag  
  339.                                   ;mov   bx,ax
  340.         and   ax,1          ;cambias esto            ; Residuo de dividir entre 2  
  341.        
  342.        
  343.         cursor_xy W,16
  344.         add   al,48    ;suma para que aparezca el caracter en pantalla ascii
  345.         putc  al
  346.        
  347.         sub   W,2  ; y esto para convertir a octal y ya
  348.         sub   control,2
  349.         shr   flag,1
  350.                        ;sub K,1
  351.        
  352.         cmp   ecchi,40
  353.         je    acarreo
  354.         cmp   control,34
  355.         je    par
  356.         cmp   control,30
  357.         je    aux
  358.         cmp   control,26
  359.         je    zero
  360.         cmp   control,24
  361.         je    sig
  362.         cmp   control,20
  363.         je    inter
  364.        
  365.        
  366.          
  367.         cmp W,18      ;barrido para impresion de pantalla
  368.         jae binario4
  369.         add W,20
  370.         add control,20
  371.         jmp binario1
  372.        
  373.        
  374. par:
  375.         cursor_xy     20,19
  376.         putc al
  377.         jmp binario4  
  378.  
  379. zero:
  380.         cursor_xy     20,21
  381.         putc al
  382.         jmp binario4
  383. sig:
  384.         cursor_xy     20,22
  385.         putc al
  386.         cursor_xy     20,23
  387.         print ntr
  388.         jmp binario4
  389. inter:  
  390.         cursor_xy     40,19
  391.         putc al
  392.         cursor_xy     40,18
  393.         print ntr
  394.         cursor_xy     40,20
  395.         print ntr
  396.         jmp binario4
  397.  
  398. acarreo:
  399.        
  400.         cursor_xy     20,18
  401.         putc al
  402.         sub ecchi,2
  403.         jmp binario4
  404. aux:
  405.         cursor_xy     20,20
  406.         putc al
  407.         jmp binario4        
  408.        
  409.                          
  410. final:
  411.     mov ah,21h
  412.     int 21h
  413.              
  414.              
  415.              
  416.              
  417.              
  418.              
  419.              
  420.              
  421.              
  422.              
  423.              
  424.              
  425.              
  426.              
  427.              
  428.        
  429.      
  430. ;/////////RUTINA SCAN_NUM
  431.    
  432. ; -32768 : 65535
  433. ; gets the multi-digit SIGNED number from the keyboard,
  434. ; and stores the result in CX register:
  435. SCAN_NUM        PROC    NEAR
  436.         PUSH    DX
  437.         PUSH    AX
  438.         PUSH    SI
  439.        
  440.         MOV     CX, 0
  441.  
  442.         ; reset flag:
  443.         MOV     make_minus, 0
  444.  
  445. next_digit:
  446.  
  447.         ; get char from keyboard
  448.         ; into AL:
  449.         MOV     AH, 00h
  450.         INT     16h
  451.         ; and print it:
  452.         MOV     AH, 0Eh
  453.         INT     10h
  454.  
  455.         ; check for MINUS:
  456.         CMP     AL, '-'
  457.         JE      set_minus
  458.  
  459.         ; check for ENTER key:
  460.         CMP     AL, 0Dh  ; carriage return?
  461.         JNE     not_cr
  462.         JMP     stop_input
  463. not_cr:
  464.  
  465.  
  466.         CMP     AL, 8                   ; 'BACKSPACE' pressed?
  467.         JNE     backspace_checked
  468.         MOV     DX, 0                   ; remove last digit by
  469.         MOV     AX, CX                  ; division:
  470.         DIV     ten                  ; AX = DX:AX / 10 (DX-rem).
  471.         MOV     CX, AX
  472.         PUTC    ' '                     ; clear position.
  473.         PUTC    8                       ; backspace again.
  474.         JMP     next_digit
  475. backspace_checked:
  476.  
  477.  
  478.         ; allow only digits:
  479.         CMP     AL, '0'
  480.         JAE     ok_AE_0
  481.         JMP     remove_not_digit
  482. ok_AE_0:        
  483.         CMP     AL, '9'
  484.         JBE     ok_digit
  485. remove_not_digit:      
  486.         PUTC    8       ; backspace.
  487.         PUTC    ' '     ; clear last entered not digit.
  488.         PUTC    8       ; backspace again.        
  489.         JMP     next_digit ; wait for next input.      
  490. ok_digit:
  491.  
  492.  
  493.         ; multiply CX by 10 (first time the result is zero)
  494.         PUSH    AX
  495.         MOV     AX, CX
  496.         MUL     ten                  ; DX:AX = AX*10
  497.         MOV     CX, AX
  498.         POP     AX
  499.  
  500.         ; check if the number is too big
  501.         ; (result should be 16 bits)
  502.         CMP     DX, 0
  503.         JNE     too_big
  504.  
  505.         ; convert from ASCII code:
  506.         SUB     AL, 30h
  507.  
  508.         ; add AL to CX:
  509.         MOV     AH, 0
  510.         MOV     DX, CX      ; backup, in case the result will be too big.
  511.         ADD     CX, AX
  512.         JC      too_big2    ; jump if the number is too big.
  513.  
  514.         JMP     next_digit
  515.  
  516. set_minus:
  517.         MOV     make_minus, 1
  518.         JMP     next_digit
  519.  
  520. too_big2:
  521.         MOV     CX, DX      ; restore the backuped value before add.
  522.         MOV     DX, 0       ; DX was zero before backup!
  523. too_big:
  524.         MOV     AX, CX
  525.         DIV     ten  ; reverse last DX:AX = AX*10, make AX = DX:AX / 10
  526.         MOV     CX, AX
  527.         PUTC    8       ; backspace.
  528.         PUTC    ' '     ; clear last entered digit.
  529.         PUTC    8       ; backspace again.        
  530.         JMP     next_digit ; wait for Enter/Backspace.
  531.        
  532.        
  533. stop_input:
  534.         ; check flag:
  535.         CMP     make_minus, 0
  536.         JE      not_minus
  537.         NEG     CX
  538. not_minus:
  539.  
  540.         POP     SI
  541.         POP     AX
  542.         POP     DX
  543.         RET
  544.  
  545. SCAN_NUM        ENDP
  546.  
  547. ;//////// RUTINA HEXADECIMAL
  548.  
  549. Hexa        proc    near
  550.             push    bp
  551.             mov     bp,sp
  552.             mov     al,[bp+4]
  553.             shr     al,4
  554.             add     al,48
  555.             cmp     al,58
  556.             js      nible2
  557.             add     al,7
  558. nible2:     mov     B,al
  559.             mov     al,[bp+4]
  560.             shl     al,4
  561.             shr     al,4
  562.             add     al,48
  563.             cmp     al,58
  564.             js      nible1
  565.             add     al,7
  566. nible1:     mov     B[1],al
  567.             pop     bp
  568.             ret
  569. Hexa        endp
  570.  
  571. ;////////////FIN DEL PROGRAMA
  572.  
  573.  
  574.  
  575. .exit
  576.  

6
C / C++ / Estructura de Datos [Cola Circular][C]
« en: Junio 26, 2015, 12:23:05 pm »
Este es el primer tema que aporto a la comunidad. Espero que ayude a más de uno que se esta aventurando en estos temas. El programa tiene un pequeño error en la eliminación de los datos (cola circular) que no he podido arreglar, pero servirá como algoritmo base para cualquier pionero o perdido del tema.
Código: C
  1. #include<stdio.h>
  2. #include<conio.h>
  3. #include<string.h>
  4. #include<stdlib.h>
  5. /*PROYECTO#2
  6.  Grupo:11R-122 Universidad Tecnológica de Panamá
  7. //Importante-----------------La cola funciona, hay que eliminar dos elementos y luego introducir, es un error que no hemos podido arreglar, pero por todo lo demas funciona bien
  8. */
  9. // COLA
  10. main(){
  11.  
  12.         int cola[6]={NULL}, fr,fn, max, dato, opcion,x,eliminar,i,num,k;
  13.         int *frente,*puntero;
  14.         max=6;
  15.         //cola[0]=0;
  16.         fr=0;
  17.         fn=0;
  18.         i=0;
  19.  
  20. do{
  21.  
  22. system("color 1f");
  23.  
  24. system("cls");
  25.  
  26. printf("\n\t OPERACIONES QUE SE PUEDEN HACER EN UNA COLA \n\n\n");
  27. printf("\n\t 1. Ingresar valores en la cola \n");
  28. printf("\n\t 2. Mostrar datos que contiene la cola \n");
  29. printf("\n\t 3. Eliminar valores de la cola \n");
  30. printf("\n\t 4. Salir del programa \n");
  31.  
  32. scanf("%d",&opcion);
  33.  
  34. switch(opcion){
  35. /*---------------------------------------------------*/
  36. /*---------------------------------------------------*/
  37. /* INSERTAR VALORES EN LA COLA */
  38. case 1:{
  39.         system("cls");
  40.     printf("\n\t Introduzca la cantidad de elementos de la Cola, max 5: ");
  41.         scanf("%d",&num);
  42. //      max=max+1; //quitar si se estropea
  43.         printf("\n\t La posicion %d esta reservada en la cola circular como frente \n",fr);
  44.  
  45.  
  46.         if(fr!=(fn+1)%max){
  47.  
  48.  
  49.     //fn=(fn+1)%max;
  50.     for(i=0; i<=num; i++){
  51.  
  52.     printf("\n\t %d final esta ",fn);
  53.     if(fn==fr)
  54.     {
  55.       i=i+1;
  56.     }
  57.     fn=fn+1;
  58.  
  59.         printf("\n\t Introduzca el dato %d de la cola:\n",fn);
  60.         scanf("%d",&dato);
  61.         cola[fn]=dato;
  62.  
  63.  
  64.         printf("\n fn =%d ",fn);
  65.         printf("\n fr =%d", fr);
  66.  
  67.      }
  68.     }
  69.  
  70.     else
  71.     printf("La cola esta llena");
  72.     printf("\n final es %d ",fn);
  73.      if(fn==max)
  74.      {
  75.          fn=0;
  76.      }
  77.  
  78. }
  79. break;
  80.  
  81.  
  82. /*---------------------------------------------------*/
  83. /*---------------------------------------------------*/
  84. /* MOSTRAR VALORES DE LA COLA */
  85. case 2:{
  86.  
  87.         system("cls");
  88.  
  89.         if(fr==fn)
  90.         {
  91.          printf("\n\t La cola esta vacia");
  92.         }
  93.     else
  94.         {
  95.         printf("\n Datos de la cola: \n"); i=i+20;
  96.     for(i=1; i<max; i++)
  97.         {
  98.  
  99.     printf("%d \n",cola[i]); //cambiar a fn si se estropea el programa
  100.      }
  101.         }
  102.     printf("\n Final=%d ",fn);
  103.     printf("\n Frente=%d ",fr);
  104. }
  105. break;
  106. /*---------------------------------------------------*/
  107. /*---------------------------------------------------*/
  108. /* ELIMINAR VALORES EN LA COLA */
  109. case 3:{
  110.  
  111.  system("cls");
  112.  
  113. if(fn==fr)
  114. {
  115.         printf("\n\t Cola vacia");
  116. }
  117. else
  118. {
  119.     printf("\n\t Cuantos elementos desea eliminar: ");
  120.     scanf("%d",&eliminar);
  121.         //fr=(fr(fr+1)%max);
  122.         for(x=0; x<eliminar; x++)
  123.         {
  124.     frente=&cola[0];
  125.     //cambiar a menos si se estropea el programa
  126.         frente[fr]=NULL; //quitar esto si se estropea el programa
  127.         fr++;
  128.     frente[fr]=NULL;
  129.         frente=&cola[fr];
  130.         printf("\n\t El elemento de la posicion %d fue eliminado",fr);
  131.         /* if(fr>fr-1)
  132.      {
  133.          i=i-fn;
  134.       //   fn=fn-1;
  135.       //   puntero=&num;
  136.        //  puntero=NULL;
  137.  
  138.     }*/
  139.  
  140.  
  141.      }
  142. }
  143. }
  144.  
  145. break;
  146.  
  147. /*---------------------------------------------------*/
  148. /*---------------------------------------------------*/
  149. /* SALIR DEL PROGRAMA*/
  150. case 4:{
  151.  
  152. printf("\n Saliendo del programa ");
  153. return 0;
  154. }
  155. break;
  156. }
  157. }while(opcion<5);
  158. }
  159.  
  160.  
  161.  
  162.  

7
Presentaciones / Yoharo ^^
« en: Abril 25, 2015, 10:58:39 pm »
Hola bueno, soy nuevo, me intereso el tema del hacking desde hace mucho tiempo. Estudio redes informaticas en mi universidad, tengo como hobbies ver anime, estudiar japonés y trastear el pc, casi siempre estoy haciendole alguna trastada y termino perdido xD bueno soy nuevo en este tema y quiero aprender mucho de ustedes, es la razón por la que me he registrado y me he unido, de todos los foros que habian me registré aqui porque vi la cantidad de temas y me parecio razonable. Tambien porque me estoy descargando el kali para empezar a aprender ^^ por ahora me sentaré a leer y de vez en cuando pedir ayuda xD y algun dia poder postear algo util. Saludos
Perdonen a los moderadores de la zona ya que desconozco el foro y no se si esta en la sección correcta

Páginas: [1]