Codigo ASM para T3G???

[Fulgore]

Hola, he estado leyendo bastante sobre el TEAM y los emus de tarjetas T3G en españa. Lo del logger me parece buena idea pero donde yo vivo parecemos hormigas y no hay una sola cabina en la q no ayan dos personas yamando... .

Asiq como no puedo pasar a la accion hasta q alguien obtenga unos cuantos log para estudiarlos pos me puesto a rebuscar por aki y por aya y me topado con un codigo en asm que supuestamente emula las tarjetas T3G, salvo por un problema de c/r al principio. Aun no he tenido tiempo de probarlo ni nada pero lo adjunto para q le echeis un vistazo y me digais (si teneis ocasion de probarlo) si es bueno.

No suelo postear muxo porq ara toy de practicas del modulo y tng un proyecto en desarroyo...pero intentare echar una mano en lo q sea (sobre todo en programacion q es mi campo).

Enga muxas gracias y animo a todos.

CODIGO ASM:

;###################################################################################
;# Emulador de Tarjetas SLE4436 (T3G) v1.2                                        #
;# Diseñado Por: JMB4U (www.bruah.es.vg)                                          #
;# Hardware: DIL o SMD (Preferiblemente Diodo)                                    #
;# Pulsador: Entre Pata 17 y Vcc (Patas 17>-<4)                                    #
;# Resistencia Pulsador: de 4k7 a 47K Entre Pata 17 y GND (Patas 17>-<5)          #
;# Resistencia Oscilacion: (Si es tipo "A" debe de llevar un Condesador de 100nF)  #
;#           en un -04: Entre 8K2 y 18K                                        #
;#           en un -10: Entre 6K8 y 18K                                        #
;#           en un -20: Entre 4K7 y 18K                                        #
;# Disclaimer: Para uso educativo y NO lucrativo, no me responsabilizo del mal    #
;#            Uso que se le pueda dar ya que es DELITO usarlo en una Cabina.      #
;# LammerInfo: Este ASM Sólo puede ser descargado desde: http://www.bruah.es.vg/  #
;###################################################################################
   LIST P=PIC16F84
   #INCLUDE <P16F84.INC>
        __CONFIG _CP_ON & _WDT_OFF & _RC_OSC
; Definicion de Macros para mayor Comodidad
#define        BANK1      BSF STATUS, RP0       ; Macro BANCO 1
#define        BANK0        BCF STATUS, RP0     ; Macro BANCO 0
#define        RST              PORTB, 0
#define        IO                 PORTA, 4
#define        CLK               PORTB, 7

; Variables en RAM
BitCounter    EQU    0x0C            ; Contador de Bits en el BYTE
#define      WRITED  0x0D,1          ; Bit Activo Si Se Puede Borrar
BACKUP       EQU    0x0E            ; Para Guardar Temporalmente EEDATA
CCounter   EQU   0x0F
BYTE3      EQU   0x10
BYTE4      EQU   0x11
BYTE5      EQU   0x12
BYTE6      EQU   0x13
BYTE      EQU   0x14
BYTEN      EQU   0x15
BitCounter2   EQU   0x16
C0      EQU   0X17      ; Byte 0 Del Challenge
C1      EQU   0X18      ; Byte 1 Del Challenge
C2      EQU   0X19      ; Byte 2 Del Challenge
C3      EQU   0X1A      ; Byte 3 Del Challenge
C4      EQU   0X1B      ; Byte 4 Del Challenge
C5      EQU   0X1C      ; Byte 5 Del Challenge
R0      EQU   0X1D      ; Byte 0 Del Response
R1      EQU   0X1E      ; Byte 1 Del Response
;*********************************************************************************
        ORG    0x2100                                 ; MAPA EEPROM
        DE      0xEC, 0x3C, 0x33, 0x0F                 ; 
        DE      0x3A, 0xBB, 0xCC, 0xD0                 ; A,BB,CC,D=Numero De Serie
   DE      0x00, 0x01, 0x01, 0x07, 0x00        ; Ábaco 6 €
        DE      0xFE               ; Byte 13, Activacion del C/R
        DE      0x00, 0x00            ; Authentication key 1
        DE      0xFF, 0xFF, 0xFF, 0xFF
        DE      0xFF, 0xFF, 0xFF, 0xFF
        DE      0xFF, 0xFF, 0xFF, 0xFF
        DE      0xFF, 0xFF, 0xFF, 0xFF
        DE      0xFF, 0xFF, 0xFF, 0xFF
        DE      0xFF, 0xFF, 0xFF, 0xFF
        DE      0xFF, 0xFF, 0xFF, 0xFF         ; Authentication key 2
        DE      0xFF, 0xFF, 0xFF, 0xFF         ; Authentication key 2
        DE      0xFF, 0xFF, 0xFF, 0xFF
        DE      0xFF, 0xFF, 0xFF, 0xFF
        DE      0xFF, 0xFF, 0xFF, 0xFF

;*********************************************************************************
   ORG    0x00                                   ; Vector de MCLR, VCC=1
   BTFSS   PORTA,0
   GOTO   INICIO
   GOTO   RECARGA
;*********************************************************************************
        ORG    0x04       ; Vector de interrupcion
;*********************************************************************************
; Vector de Interrupcion, Se Detecta si es RESET, WRITE o Writecarry
;*********************************************************************************
INT     BTFSC  CLK            ; Detecta si CLK es 1 para RST
        GOTO    RESET          ; Si Lo es, Produce RESET
        BTFSC  RST               ; No Hay Reset, puede ser borrado o Writecarry
        GOTO    INT               ; Ni RESET ni WRITE ni Writecarry, keep Waiting...
        BTFSC  EEDATA,7        ; 
        BSF    IO               ; Si RESET=0, Saca el Ultimo BIT Usado
        BTFSS  WRITED         ; Si WRITED es 1 se prudujo un borrado antes
        GOTO    WRITE          ; por lo que pasara a hacer Writecarry
        GOTO    WCARRY

;*********************************************************************************
; Reset General De La Tarjeta (MCLR), Configuracion del Puertos
;*********************************************************************************
INICIO  BANK1
        BCF       TRISA,4      ; RA4 salida, PORTB entradas
   BANK0
   MOVLW   0x88      ; Direccionamiento indirecto de EECON1
   MOVWF   FSR
;*********************************************************************************
; Reset del Contador de Direcciones
;*********************************************************************************
RESET   ;BTFSC   CLK      ; Deberia Esperar a Que Baje CLK...
   ;GOTO   $-1      ;      ---------
            ; _____|      |__________ RST
            ;            ------
            ; ___________|    |_______ CLK
            ; Pero Como Asi Tambien Se Reseta, Pos da igual...
   CLRF    EEADR          ; Weno, Seguimos...Se direcciona BYTE0
   BSF   INDF,0      ; Y Lo leemos
        BCF    WRITED           ; No Se Puede hacer Writecarry (Por Si Acaso...)
        MOVLW  0x08
        MOVWF  BitCounter   ; Resetea el contador de bits
Wait_RST
   BTFSC  RST               ; Espera que RST=0
        GOTO    $-1
        MOVLW  b'10010000'    ; Activa interrupcion para RST (INTE y GIE)
        MOVWF  INTCON            
        BSF    IO               ; 1º bit despues del RST a 1
;*********************************************************************************
; Rutina de Proceso de la Señal de CLOCK
;*********************************************************************************
CLOCK  BTFSS  CLK      ; Espero Pulso para empezar el proceso de CLK
        GOTO    $-1   
   BCF    WRITED           ; Se desabilita la posibilidad de Writecarry
        RLF    EEDATA,1        ; Rota el siguiente bit a la izquierda
        DECFSZ  BitCounter,1     ; Quita un contador de bits, si=0 Termina Byte
        GOTO    CLKoff     ; Espera a que Baje CLK        
        MOVLW  0x08            ; Resetea el contador de bits
        MOVWF  BitCounter
        INCF    EEADR,F        ; Incrementa el contador de bytes
   MOVLW   0x3C      ; 60 bytes
   SUBWF   EEADR,0
   BTFSC   STATUS,Z   ; Comprueba que ha llegado al byte 60
        CLRF    EEADR          ; Puesta a Cero del Contador de Direcciones
   BSF   INDF,0      ; Lee byte Actual del Puntero
   
CLKoff  BTFSC  CLK             ; Espera a que CLK=0
        GOTO    CLKoff
        BTFSS  EEDATA,7        ; Bit 7 de EEDATA a I/O
        BCF    IO
        BTFSC  EEDATA,7
        BSF    IO
        GOTO    CLOCK      ; Espera el Siguiente Pulso
;*********************************************************************************
; Borrado de un Bit
;*********************************************************************************
WRITE   BTFSS  CLK            ; Espera el pulso de clk para escribir
        GOTO    $-1
;*********************************************************************************
; Proteccion de las Zona No-Borrables
;*********************************************************************************
PROTEC  MOVF    EEADR,0
        ADDWF  PCL,F
        GOTO    WNULL      ; Byte0
        GOTO    BUCLE           ; Byte1
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE           ; Byte05
        GOTO    BUCLE
        GOTO    BUCLE           
        GOTO    Writeable      ; Byte8  4096 u del Ábaco
        GOTO    Writeable      ; Byte12  512 u del Ábaco
        GOTO    Writeable      ; Byte10  64 u del Ábaco
        GOTO    Writeable      ; Byte12    8 u del Ábaco
        GOTO    Writeable      ; Byte12    1 u del Ábaco
        GOTO    CHALLENGE_TEST   ; Byte13 (bit 1 del Byte 13 es Challenge)
        GOTO    Writeable   ; Authentication key 1
        GOTO    Writeable      ; Authentication key 1
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE      ; Byte20
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE      ; Byte25
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE      ; Byte30
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE      ; Byte35
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE      ; Byte40
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE      ; Byte45
        GOTO    Writeable   ; Authentication key 2
        GOTO    Writeable      ; Authentication key 2
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE      ; Byte50
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE      ; Byte55
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE
        GOTO    BUCLE      ; Byte60 

Writeable 
   BTFSS  EEDATA,7        ; Comprueba si ya ha sido Borrado el Bit
        GOTO    WNULL           ; De No Ser Asi, Lo Borra
        BSF    WRITED      
        BCF    IO               ; Baja I/O
        MOVF    EEDATA,0        ; Backup de EEDATA
        MOVWF  BACKUP
        BCF    EEDATA,7        ; Pone el Bit a 0 para Evitar Varios Borrados

   BSF   INDF,0      ; Lee el byte en el que se quedo EEADR
        MOVF    BitCounter,0    ; Comprobamos que bit fue el ultimo leido
        ADDWF   BitCounter,0   ; para pasar a ponerlo a 0
   ADDWF  PCL,1          
        NOP         ; ¿¿Qué numero entero Entre 0 y 8 Al Multiplicarlo por 2
   NOP                    ; Tiene Como Resultado un numero Menor que 2??, NINGUNO!!!
        BCF    EEDATA,0        ; Bit0
        GOTO    EndBit
        BCF    EEDATA,1        ; Bit1
        GOTO    EndBit          
        BCF    EEDATA,2   ; Bit2
        GOTO    EndBit
        BCF    EEDATA,3   ; Bit3
        GOTO    EndBit
        BCF    EEDATA,4   ; Bit4
        GOTO    EndBit
        BCF    EEDATA,5   ; Bit5
        GOTO    EndBit
        BCF    EEDATA,6   ; Bit6
        GOTO    EndBit
        BCF    EEDATA,7   ; Bit7
        
EndBit  CALL    WEEPROM      ; Escribe el Contenido en la EEPROM
Wend    MOVF    BACKUP,0        ; Restaura el contenido Anterior de EEDATA
        MOVWF  EEDATA
WNULL    BTFSC  CLK               ; Espera a que Baje CLK
        GOTO    $-1
        MOVLW  b'10010000'    ; Activa interrupcion para RST (INTE y GIE)
        MOVWF  INTCON            
        GOTO    CLOCK

CHALLENGE_TEST
        MOVF    BitCounter,0    ; Comprobamos que bit fue el ultimo leido
        ADDWF   BitCounter,0   ; Deteccion de Escritura en Bit 110
   ADDWF  PCL,1          
        NOP         ; ¿¿Qué numero entero Entre 0 y 8 Al Multiplicarlo por 2
   NOP                    ; Tiene Como Resultado un numero Menor que 2??, NINGUNO!!!
        GOTO   BUCLE
        GOTO   BUCLE
        GOTO   Get_Challenge   ; Yeah!, A Recibir el Chellenge...
        GOTO   BUCLE
        GOTO   BUCLE
        GOTO   BUCLE
        GOTO   BUCLE
        GOTO   BUCLE
        GOTO   BUCLE
        GOTO   BUCLE
        GOTO   BUCLE
        GOTO   BUCLE
        GOTO   BUCLE
        GOTO   BUCLE
        GOTO   BUCLE

Get_Challenge
        MOVLW  b'10010000'    ; Activa interrupcion para RST (INTE y GIE)
        MOVWF  INTCON            
   MOVLW   .178      ; 177+1 por motivos de Optimizacion en el Codigo
   MOVWF   CCounter   ; Pone el Contador de Espera de Semilla
CWait   BTFSC   CLK
   GOTO   $-1      ; espero a que baje El Clock del Write
CPulse   BTFSS  CLK
        GOTO    $-1
   DECFSZ   CCounter   ; espero los 177 Ciclos para el Challenge
   GOTO   CWait
   BANK1          ; Fin De Los 177 Ciclos   
   BSF   TRISA,4      ; RA4 como Entrada
   BANK0
   MOVLW   0x06
   MOVWF   BYTEN
rec   CLRF   BYTE      ; Limpia el buffer de Recepcion (BYTE)
   MOVLW   0x08      ; Va a Recibir 8 Bits
   MOVWF   BitCounter2
rnext   BTFSS   CLK
   GOTO    $-1
   BTFSC   CLK
   GOTO   $-1      ; Espera Pulso de CLK
   BCF   STATUS,C   ; Limpia el flag C (Carry)
   BTFSC   PORTA,4      ; Mira la linea de recepcion
   BSF   STATUS,C   ; Si esta en alto sube el carry
   RLF   BYTE,1      ; Rota el buffer de recepcion
   DECFSZ   BitCounter2,1   ; Decrementa la cant. de Bits a recibir
   GOTO   rnext      ; Si faltan Bits por Recibir Continua
   CALL   LOCATEBYTE   ; Mira que Byte Estamos Tratando
   DECFSZ   BYTEN,1
   GOTO   rec
   GOTO   PROCESS

PROCESS
   MOVF   C0,0
   XORWF   C1,0
   XORWF   C2,0
   XORWF   C3,0
   XORWF   C4,0
   XORWF   C5,0
   MOVWF   R0
   COMF   R0,0
   MOVWF   R1      ; Hago este Proceso por hacer algo, porque aqui
            ; Es Donde va el Algoritmo que, 'aun' no se conoce

SendResponse         ; Envia el Resultado del algoritmo
   BANK1          
   BCF   TRISA,4      ; RA4 como sALIDA
   BANK0
   MOVLW   0x02      ; Va a Enviar 2 Bytes
   MOVWF   BYTEN
   MOVF   R0,0
   MOVWF   BYTE
ssend   MOVLW   0x08      ; Va a Enviar 8 Bits
   MOVWF   BitCounter2
Send   BTFSS   BYTE,7
   GOTO   SEND_0
   MOVLW   .160      ; Se Esperan los 160 Pulsos entre Bit y Bit
   MOVWF   CCounter   
   BTFSS   CLK
   GOTO   $-1
   BTFSC  CLK
        GOTO    $-1
   DECFSZ   CCounter   
   GOTO   $-5
   BSF    PORTA,4
   GOTO   Next
SEND_0   MOVLW   .160
   MOVWF   CCounter
   BTFSS   CLK
   GOTO   $-1
   BTFSC  CLK
        GOTO    $-1
   DECFSZ   CCounter
   GOTO   $-5
   BCF    PORTA,4
Next   RLF   BYTE,1
   DECFSZ   BitCounter2,1
   GOTO   Send
   MOVF   R1,0
   MOVWF   BYTE
   DECFSZ   BYTEN,1
   GOTO   ssend
   GOTO   CLOCK      ; Fin del Envio, Vuelve a estado normal y espera CLK

BUCLE    MOVLW  b'10010000'   ; Activa interrupcion para RST (INTE y GIE)
        MOVWF  INTCON          ; lo unico que saca del BUCLE es RST o Vcc=0  
        GOTO    $-2

;*********************************************************************************
; Rutina Del Transporte de Escritura (Writecarry)
;*********************************************************************************
WCARRY    BTFSS  CLK            ; Espera El Pulso De CLOCK Para
        GOTO    $-1      ; Comenzar el Proceso de Writecarry
   MOVF    EEDATA,0        
        MOVWF  BACKUP          ; Backup De EEDATA para Cuando Termine
        BCF       WRITED      ; Se deshabilita Writecarry
        INCF   EEADR,1      ; Incrementa EEADR al siguiente al ultimo
   MOVLW  0xFF            ; leido y lo pone a FF
        MOVWF  EEDATA
        CALL    WEEPROM
   DECF   EEADR,1      ; Pone EEADR donde estaba
        GOTO    Wend            

;*********************************************************************************
; Rutina De Escritura en EEPROM (Valores En EEDATA y EEADR Previamente)
;*********************************************************************************
WEEPROM BANK1            ; Escritura del Byte Actual en la EEPROM
        BSF    EECON1,WREN
        MOVLW  0x55
        MOVWF  EECON2
        MOVLW  0xAA
        MOVWF  EECON2
        BSF    EECON1,WR
   BTFSC  EECON1,WR       ; 
        GOTO    $-1             ; Espero a que Termine...
        BCF    EECON1,WREN
        BANK0
   RETURN                  ; Retorno de la LLamada

LOCATEBYTE
   MOVF   BYTEN, W        ; Ponemos el valor del contador de Bytes de la semilla en W
   ADDWF     PCL, F          ; Sumamos PCL + W y salta a guardar el Byte correspondiente
   NOP
        GOTO   SAVE5
        GOTO   SAVE4
        GOTO   SAVE3
        GOTO   SAVE2
        GOTO   SAVE1
   MOVF   BYTE,0
   MOVWF   C0
   RETURN
SAVE5
   MOVF   BYTE,0
   MOVWF   C5
   RETURN
SAVE1
   MOVF   BYTE,0
   MOVWF   C1
   RETURN
SAVE2
   MOVF   BYTE,0
   MOVWF   C2
   RETURN
SAVE3
   MOVF   BYTE,0
   MOVWF   C3
   RETURN
SAVE4
   MOVF   BYTE,0
   MOVWF   C4
   RETURN
;*********************************************************************************
;    Rutina Principal de Recarga.
;*********************************************************************************
RECARGA
   CALL   Abaco6E
   CALL   READSN

   INCF   BYTE5,1
   INCF   BYTE6,1
   INCF   BYTE6,1    ; Incremento del Nuemro de serie

   CALL   CHANGESN   ; Escribe el SN ya incrementado a la EEprom
   GOTO   JMB4U

;*********************************************************************************
; Rutinas de Escritura en la EEPROM
;*********************************************************************************

Abaco6E
   CLRF    EEDATA     ; Dato del Ábaco 4096 Centimos
        MOVLW    0x08      ; Este Byte siempre es 0
        MOVWF    EEADR             ; Escribe el Byte8
   CALL   WRITEE
        MOVLW    0x01
   MOVWF    EEDATA     ; Dato del Ábaco 512 Centimos
        INCF    EEADR,1           ; Escribe el Byte9
   CALL   WRITEE
        MOVLW    0x01
   MOVWF    EEDATA     ; Dato del Ábaco 64 Centimos
        INCF    EEADR,1        ; Escribe el Byte10
   CALL   WRITEE
   MOVLW    0x07
   MOVWF    EEDATA     ; Dato del Ábaco 8 Centimos
        INCF    EEADR,1           ; Escribe el Byte11
   CALL   WRITEE
   CLRF   EEDATA     ; Dato del Ábaco 1 Centimo
        INCF    EEADR,1           ; Escribe el Byte10
   CALL   WRITEE
   RETURN

WRITEE   BANK1                  ; Seleccionamos el banco 1.
RETRY   BCF   EECON1,WRERR
        BSF    EECON1,WREN    ; Permiso de escritura. 
        MOVLW    0x55            ; Inicio secuencia de escritura.
        MOVWF    EECON2
        MOVLW    0xAA
        MOVWF    EECON2
        BSF    EECON1,WR      ; Comienza la escritura.
   BTFSC    EECON1,WR      ; Y espero hasta que se complete
        GOTO    $-1             ; la escritura.
   BTFSC   EECON1,WRERR   ; Comprobacion de Error
   GOTO   RETRY      ; Joderr!!, Repite la Escritura
        BANK0                     ; No Hay error, Continua
   RETURN

CHANGESN
   MOVF    BYTE5,0
   MOVWF    EEDATA     ; Escribe El Numero De Serie
        MOVLW    0x05
   MOVWF   EEADR             ; Escribe en 05h
   CALL   WRITEE
   MOVF    BYTE6,0
   MOVWF    EEDATA     ; Escribe El Numero De Serie LSB
   INCF   EEADR,1        ; Escribe en 06h
   CALL   WRITEE
   RETURN

READSN   MOVLW  0x05            ; Lee El Byte5 y lo almacena en la variable BYTE5
   MOVWF   EEADR
   BANK1         
   BSF   EECON1,RD
   BANK0
   MOVF   EEDATA,0
   MOVWF   BYTE5

        INCF     EEADR,1      ; Lee El Byte6 y lo almacena en la variable BYTE6
   BANK1
   BSF   EECON1,RD
   BANK0
   MOVF   EEDATA,0
   MOVWF   BYTE6
   RETURN

JMB4U   NOP         ; Fin de la Recrga
        GOTO    JMB4U
   END

NOTA: Lo siento por lo extenso del post.

[SxR]

Ok, le echaré un vistazo

[g0dy]

mmmmmm, muy muy interesante...
le echaré varios vistazos...

[JNZDS]

Es pa darle bastantes vistazos, xo como no se ASM xDD, aunque ya me estoy poniendo a estudiarlo. por cierto alomejor tengo una sam0 de hace un 1 año que vi una cabina abierta arrase con la cabina xDD xo no se si la tire me canse y creo que se fue al garrete bajon xDD,

[g0dy]

He estado leyendo la pagina original donde viene el código este. Es un foro de phreacking mexicano.
En dicho foro dicen que el código tiene un problema con el C/R, pero OJO, con el C/R de las cabinas de méxico (o eso he entendido yo), el autor de este código es español, por lo tanto intuyo que este código debería funcionar en las cabinas españolas.

Le he echado unos cuantos vistazos y en principio parece que podría funcionar, aunque no conozco el protocolo que utilizan la cabina y la tarjeta para comunicarse.

La pagina principal del foro del que os hablo es: http://www.hakim.ws/cum/index.html

La pagina del subforo donde se trata el tema es:
http://www.hakim.ws/foro/index.php?board=11

La pagina del tema donde aparece el código es:http://www.hakim.ws/foro/index.php?board=11;action=display;threadid=4640

más concretamente en la segunda pagina:
http://www.hakim.ws/foro/index.php?board=11;action=display;threadid=4640;start=15

Un avance muy importante pienso yo sería intentar contactar con el autor de este código (JMB4U), para que comparta la información que tiene.

SxR, en lo referente a libros e información sobre tarjetas inteligentes, estuve buscando en mi universidad y únicamente hay 2 libros y los 2 están "No disponibles". Sabes alguna fuente de información on-line ? Ya he buscado por google un poco... pero dicen poca cosa.

Suerte en la búsqueda ,

Saludos

PD: La pagina de JMB4U no va, mm, la habrán retirado xq dicho código funcionaba ?

[puskas6]

Buenas a todos , nada mas q informaros q ese codigo funciono en su dia hasta q se introdujo la SAM y con ella el C/R yo mismo lo probe y aseguro funcionoel dueño del ASM tambien fue el creador del "READER by JMB4U"

CARACTERÍSTICAS GENERALES:
-Obtención del DUMP de una tarjeta de 128 Bits (En T3G, Lee los primeros 128 Bits)(*)
-Análisis de los datos del DUMP Obtenido, ya sea FNMT, G+D... 1000Ptas, 2100Ptas, 6€, T3G, T2G...(*)
-Comprueba si el Checksum (T2G) del DUMP es el correcto si no, puede corregirlo.(*)
-Permite la edición del DUMP obtenido (Numero De Serie, Fabricante, Abaco...)(*)
-Se Pueden cambiar/Corregir cualquiera de los 16 Bytes del DUMP(*)
-Puede Almacenar Hasta 16 Dumps en la EEPROM interna del µPIC para su estudio posterior sin necesidad de la Tarjeta.(*)
-Permite la Escritura/Reparación de un Emulador (Con BackDoor Implementado) para corregir el DUMP o Recargarlo(*)
-Permite Dos Velocidades de lectura de Dump, tiempo real y lento (Por si se quiere efectuar una recarga en el tiempo justo)(*)
-Permite la Emulación de un DUMP guardado en la EEPROM (u Obtenido) en tiempo real, se conecta con una interfaz al Lector de tarjetas y Emula como si fuera una tarjeta y muestra Información en la Pantalla...
-Dispone de 3 Leds y un Buzzer (Pitido) que muestran el estado actual del Reader.(*)
-Permite la conexión de un Logger (Diseñado por DarkMan) y muestra la información necesaria en la LCD
-Permite Cambiar la Configuracion del Propio Reader: Leds y Beeper(*)
-Permite Enviar un Challenge a la Tarjeta y Leer su Response usando Key1 ó Key2(*)
-Si Sobra memoria y se me ocurren mas cosas, pos ya se las pondré...(Se Aceptan Sugerencias...)
(*) Ya Implementado


Y nada mas q decir solo q el tema principal q yo veo q hay q abordar es el del C/R y intentar implementarlo a los asm o al hardware q ya hay creados como este de 3ª generacion o slimcards.
Saluda un servidor

[debuti]

hola, he estado mirando el codigo y no hay por donde cogerlo si no te sabes al menos cual es el protocolo entre la kbina y la tarjeta...me podriais explicar un poco que es lo q queremos emular?gracias y perdon por mi estulticia