Proyecto Terminal

Seguridad de los teléfonos públicos de tarjetas

Profesor: Omar Lucio Cabrera Jiménez

Alumno: Carlos Manuel Damken Castell

Matrícula: 91224358

1

Índice: Hipótesis.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.2 Investigación-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.2 Partes necesarias-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.2 Forma de elaborarlo-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.4 Prueba complementaria.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.7 Lector de la tarjeta telefonica-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.9 Programa para la Tarjeta.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.14 Conclusiones-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.24 Anexo 1 .- Emulador de tarjetas PROM-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.25 Anexo 2 .- Información de las tarjeta telefonicas-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.31 Anexo 3.- Salida de Tarjeta Telefonica.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.36

2

Hipótesis:

El proyecto inicio gracias a unos documentos encontrado alguna vez en la red, sobre la forma de crear una tarjeta de teléfono, lo pongo en los Anexos para hablar de ellos, lo importante es probar si existe una forma de utilizar los teléfonos públicos con una tarjeta telefónica que no se le termine el crédito. Investigación:

Como ya hemos visto, la realización práctica del EMULADOR DE TARJETA TELEFONICA propuesta por José Manuel García, enmascara grandes inconvenientes que nada tienen que ver a nivel de diseño, que a 'ojo de buen cubero' parece querer cumplir. Por un lado el tipo de memoria utilizada, no se encuentra disponible en el mercado callejero de semiconductores, ni tan siquiera una equivalencia que se aproxime a el fin de probar si se puede generar una tarjeta. Además de esto y por si fuese poco, las placas de circuito impreso que normalmente se adquire en la calle tienen un espesor que no nos permite introducir el invento en su ranura correspondiente; todo ello muy lejos de hacernos capaces de probarlo. Partes necesarias:

En el nuevo esquema diseñado, hay representados dos contactos telefónicos (KEYPHONE) uno para alojar al chip de ROM (previa soldadura sobre un socket de 8 pines o directamente), y el otro para realizar la conexión con una tarjeta de teléfono ya agotada (sin crédito). Los útiles necesarios y que se requieren son: 1 integrado 74HC393 1 integrado 74HC139 1 integrado 74HC02 1 memoria RAM tipo 6116 (Equivalencias: uPD4016, TMM 2016, TMM2015, MN4216) 1 tira de 40 pines (torneados) para darle elevación a la RAM. 1 socket de 8 pines para soldar la ROM (a título personal si así se desea). 2 diodos 1N4148 (¡No confundir la polaridad en el circuito!). 1 transistor BC547B 2 resistencias de 22K (1/4 Watt) 1 resistencia de 15K (1/4 Watt) 1 resistencia de 3.3K (1/4 Watt) 1 resistencia de 1.5K (1/4 Watt) 1 metro de cable de cinta plana de 10 contactos (solo utilizaremos 7). 1 conector IDC de 10 contactos (macho acodado para circuito impreso). 1 conector IDC de 10 contactos (hembra para cable de cinta plana).

3

1 trozo de placa de C.I. de 70mm x 40mm sensibilizada fotosensibilizada a doble cara (positivo) o bien una placa de prototipos de unos 100mm x 100mm. Además necesitarás conseguir 2 tarjetas de teléfono agotadas (una a modo de soporte entre el teléfono y el artefacto, y otra para implementar la ROM). Si se opta por realizar la placa, durante el proceso de taladrado de la misma, se recomienda utilizar una broca de 0.7mm de diámetro, y realizarlo con mucha maña. Igualmente, para las soldaduras, usar un cautín de punta tipo lápiz de 30W o algo parecido para que no dañe las pistas o los semiconductores. NOTA: Los circuitos integrados, deben ser de la serie 74HCxxx, y en su defecto también pueden valer estos otros: 74HCTxxx, 74HCTLxxx o 74Cxxx, de ningún modo usar los 74xxx ó 74LSxxx.

4

Forma de Elaborarlo: Para poder paliar esta sufrida situación, os proponemos el siguiente esquema eléctrico que ha sido simulado convenientemente con PSPICE y OrCAD dst, para evitar malos sustos, no obstante es posible que en la práctica los resultados no sean del todo los esperados debido en parte a algunos aspectos críticos del circuito. Como se puede ver el circuito ha sido brutalmente modificado de manera poco ortodoxa aunque muy inteligente, utilizando los elementos más baratos y conocidos de cualquier tienda de electrónica. Además, la modificación ha implicado una reducción del número de circuitos integrados y varios detallitos sin importancia que creemos que como lección de electrónica técnica permite explicar con detalle para que se vea como 'la lógica es la que impera'. Para empezar, todos los circuitos integrados salvo la memoria RAM consumen unos pocos microamperios en reposo ya que son circuitos que según sus características técnicas, pueden ser alimentados desde 2V a 6V (tecnología HCMOS). La memoria elegida es curiosamente una 6116 de la que solamente se va a aprovechar un solo bit de los primeros 256 bytes iniciales, ya que se han empeñado en ponernos las cosas difíciles. Los otros 7 bits se desprecian en este invento, pues la necesidad es la que prima y la memoria no es un componente tan caro como para no justificar esta decisión. La segunda operación realizada a la tarjeta ha sido también determinante. Dado que tenemos un buen soporte que cumple con las dimensiones y espesores que requiere la mencionada ranura, utilicemos pues el material de la propia tarjeta en nuestro provecho.

5

Basta con seguir las siguientes explicaciones: a) Trepanar la tarjeta por la cara posterior a los contactos destruyendo si es necesario el chip que hay interiormente (realícese esta operación con sumo cuidado para evitar dañar los contactos). b) Limpiar con cuidado los contactos de residuos plásticos (resina epoxi), y preestañarlos rápidamente para evitar deformaciones térmicas del plástico. c) Cortar con una cuchilla rígida, las ranuras que hemos indicado sobre la tarjeta. d) Pelar los 7 contactos que vamos a usar del cable de cinta plana. e) Realizar una soldadura de los contactos según el orden establecido en nuestro esquema. (Soldar de forma rápida para evitar exceso de calor a los contactos.) f) Pasar el cable de cinta plana por las dos ranuras exteriores.

Después de ésta operación, u otra parecida que se pueda ocurrir, pasaremos el cable de cinta plana primero por debajo de la ranura (A) y luego de arriba hacia abajo por la ranura (B). Tras alojar el cable en la ranura (C) y soldar manteniendo todo tenso. Después siendo realmente mañosos se fija el cable con un pegamento de contacto, alguna resina sintética o simplemente con celofán suficientemente fino, de manera que le de consistencia y rigidez. La tercera operación consiste ahora en extraer el chip de la otra tarjeta, para lo que se utiliza unas tijeras y se recorta el área rectangular que interesa. Después las soldaduras se realizarán directamente en los contactos previamente estañados y en el más corto espacio de tiempo para evitar que se destruya el chip.

Ranura C

Ranura B

Ranura A

6

Ya solo queda por realizar la placa de circuito impreso a doble cara del invento, que como se puede apreciar, se ha querido reducir el espacio físico sin el uso de componentes de montaje superficial. Dado que siendo conscientes de que no todo el mundo sea capaz de realizar la placa de circuito impreso, insisto en dar como solución que se utilice una placa de circuito impreso ya perforada para ensayo de prototipos que se venden en cualquier tienda. Si se opta por esta última solución, se ve que el circuito quedará estéticamente poco visible tras realizar el cableado de la misma pero si se hace todas las soldaduras correctas, conseguiremos su funcionalidad ( Lo funcional antepuesto a lo estético). A continuación, aparece el trazado de pistas a doble cara del C.I. cuyo tamaño en la realidad deberá tener unas dimensiones de 66mm x 37mm; estas medidas te pueden servir de referencia para ajustar la escala gráfica cuando se mande el gráfico por impresora. Si no se tiene claro, utilizar cualquier otra herramienta gráfica que permita el formato DXF tal como AutoCAD, e importar el fichero PCB.DXF.

7

PRUEBAS COMPLEMENTARIAS: Analizemos ahora el circuito, indicando los módulos existentes, su configuración individual y los procesos tanto de lectura como de escritura. Como puede apreciarse en el esquema, el C.I. 74HC393 está realizando la tarea de direccionar la memoria 6116 en sus primeros 256 bytes. La decodificación del permiso de selección de la RAM, se realiza a partir de la dirección 96 (decimal) por medio de las líneas A5, A6 y A7 en colaboración con los diodos D1, D2 y R5 (puerta AND sintetizada), y U3D (puerta NOR). Además el diseño con el doble demultiplexor 74HC139 por un lado el control de la lectura o escritura en la RAM así como la lectura de la ROM gracias a U4B, encargándose de dar permiso al dato de entrada DIN, la otra mitad del integrado, representada por U4A. El truco está en que aunque el direccionamiento de ambas (RAM y ROM) se realiza simultáneamente, Q1 dota a la ROM de un buffer triestado monobit con lo que los datos de uno u otro pueden seleccionarse sin interferirse. Para un mejor entendimiento supongamos los siguientes casos: a) Operación de lectura en direcciones inferiores a la 96: La señal CS estará a nivel lógico alto, con lo que no se direcciona la RAM pero si la ROM. Como se ve, el transistor BC547B, realiza la función de buffer triestado ya que la base esta directamente polarizada con R2. La resistencia R1 limita la corriente de colector y mantiene el bus de E/S monobit libre de señales espúreas al estar conectada a la tensión de alimentación. Gracias a U3C y U3B la salida del dato queda amplificada al estado lógico correspondiente. b) Operación de escritura en direcciones inferiores a la 96: Esto es del todo imposible ya que el pin 13 de U4B esta a nivel alto siempre, manteniéndose los pines CE, OE y WE de la RAM siempre a estado lógico alto. c) Operación de lectura en direcciones superiores a la 96: La señal que viaja al pin CE de la RAM, esta a nivel lógico bajo, y la base del transistor Q1, se encuentra al mismo nivel con lo que se desactiva cualquier señal procedente de nuestra ROM aunque sigue siendo direccionada. El bit D0 de la RAM ya no se encuentra en alta impedancia al estar leyendose por encima de la dirección 96 d) Operación de escritura en direcciones superiores a la 96: Siempre que La señal de tensión de programación aparezca, por medio de las resistencias R3 y R4 que forman un divisor de tensión 1:11 , originarán una tensión de +1.9V justo a la entrada del demultiplexor U4B, con lo que la señal WR que va a la RAM se habilita (nivel lógico bajo) dandose a su vez permiso de entrada del dato por medio de U4A. En este instante, las señales CE y WE se encuentran a cero lógico pero no la de OE (Output Enable), por lo que es posible una escritura. El bit de datos de la ROM si te das cuenta, sigue desactivado del bus de dato. No cantemos aun victoria, pues aunque la lógica funcione correctamente, es posible que tengamos problemas de funcionamiento imprevisto. Tened en cuenta que la

8

información obtenida para el desarrollo de este circuito está basada en otro anterior del que a ciencia cierta poco se sabe. Chips requeridos: Te describimos a continuación, la descripción del encapsulado de los circuitos integrados para que no tengas errores a la hora de conectarlos:

74HC02

14 13 12 11 10 9 8

1 2 3 4 5 6 7

Vcc=2..6v pin14GND= pin7

74HC139

14 13 12 11 10 9

1 2 3 4 5 6 7

Vcc=2..6v pin16

GND= pin8

8

1516

74HC393

14 13 12 11 10 9 8

1 2 3 4 5 6 7

Vcc=2..6v pin14GND= pin7

HM6116

24 23 22 21 20 19 18

1 2 3 4 5 6 7

Vcc=2..5v pin24GND= pin12

17 16 15 14 13

8 9 10 11 12

K

A

1N4148

9

Lector de la Tarjeta Telefonica: Ahora lo que necesitamos es leer una tarjeta de Teléfonos para ver su información: Para eso se desarrolla un programa: Program Lector; Uses CRT,Dos; Const Start=184 "10111000" ; Reset1=056 "00111000" ; Reset2=120 "01111000" ; Clock1=248 "11111000" ; Puerto=888; Var Todo:Array[1..32] of Byte; n1,n2,n3,e,x, y, nlecturas:Byte; op:char; CHKSum,Usado,Cont:Byte; tiempo:Longint; Valor,Serie,Espera:Longint; Mal,Cero,Temp:Boolean; h, m, s, hund : Word; For GetTime tseg,tfrac,seg,frac:Word; Delay2:Word; tarda:Real; Procedure Reset; Begin Port[Puerto]:=Reset1; For Tseg:=1 to Tiempo do Begin; End; Port[Puerto]:=Reset2; For Tseg:=1 to Tiempo do Begin; End; Port[Puerto]:=Reset1; For Tseg:=1 to Tiempo do Begin; End; End; Procedure Clock; Begin Port[Puerto]:=Clock1; For Delay2:=1 to Tiempo do Begin; End; Port[Puerto]:=Start; For Delay2:=1 to Tiempo do Begin; End; End; Function Pot(b,p:byte):longint; Var i:byte;

10

t:longint; Begin t:=1; For i:= 1 to p do t:=t*b; Pot:=t; End; Procedure Val; Begin Valor:=0; Valor:=(Todo[9]and 63)*8; Valor:=Valor+(Todo[10]and 224)Div 32; End; Procedure SerieT; Begin Serie:=0; Serie:=(Todo[5] and 31)*Pot(2,26); Serie:=Serie+Todo[6]*Pot(2,18); Serie:=Serie+Todo[7]*Pot(2,10); Serie:=Serie+Todo[8]*Pot(2,2); If Todo[9] and 128=128 Then Serie:=Serie+2; If Todo[9] and 64=64 Then Serie:=Serie+1; End; Procedure CambiaDelay; Begin GotoXY(1,6); Write('Nuevo Delay='); Read(Tiempo); GotoXY(1,6); Write(' '); End; Procedure Credito; Begin Usado:=0; Mal:=False; Temp:=False; Cero:=False; If Todo[13] and 8 = 8 Then Usado:=Usado+1; If Todo[13] and 4 = 4 Then Usado:=Usado+1; If Todo[13] and 2 = 2 Then Usado:=Usado+1; If Todo[13] and 1 = 1 Then Usado:=Usado+1; For Nlecturas:= 14 to 31 do Begin For Espera:= 7 downto 0 do Begin If Todo[Nlecturas] and Pot(2,Espera)<>0 Then Begin Usado:=Usado+1; IF Cero=True Then Mal:=True; End Else Cero:=True; End; End; End;

11

Procedure CHK; Begin CHKSum:=0; For Nlecturas:= 2 to 12 do Begin For Espera:= 0 to 7 do Begin If Todo[Nlecturas] and Pot(2,Espera)<>0 Then Inc(CHKSum); End; End; End; Procedure PintaTodo; Var a,b,t2,t3,t4:byte; Begin For a:= 1 to 8 do Begin; GotoXY(20,a+8); For b:= 1 to 4 do Begin; Write (Todo[(a-1)*4+b]:3,' '); End; End; For a:= 1 to 8 do Begin; GotoXY(5,a+8); For b:= 1 to 4 do Begin t2:=Trunc(Int(Todo[(a-1)*4+b]/16)); if t2>9 Then t4:=t2+55 Else t4:=t2+48; t3:=Todo[(a-1)*4+b]-t2*16; if t3>9 Then t3:=t3+55 Else t3:=t3+48; Write(CHR(t4),CHR(t3),' '); End; End; CHK; GotoXY(40,6); If CHKSum = 216-Todo[1] Then Writeln('CheckSum Correcto') Else Begin Writeln(' ');Sound(1000);For Espera:=1 to 100000 do Begin; End;Nosound;End; SerieT; GotoXY(40,8); Writeln('Serie de la tarjeta:',Serie,' '); Val; GotoXY(40,9); Write('Valor de la tarjeta:',Valor,' '); Credito; GotoXY(40,10); Writeln('Credito Usado:',Usado/2:2:2,' '); GotoXY(40,11); If Todo[32]=255 Then Writeln('Crédito Agotado')

12

Else Writeln(' '); GotoXY(40,13); IF Mal=True Then Writeln ('Error en el área de crédito'); GotoXY(40,15); Writeln('Delay=',Tiempo,' '); End; Procedure Obten; Begin GotoXY(1,20); Port[Puerto]:=Start; For n1 := 1 to 32 do Begin For n2:=1 to 8 do Begin e:=Port[Puerto+1]and 128; If e<>128 Then Begin Write('1'); Todo[n1]:=Todo[n1]+Trunc(Pot(2,8-n2)); End Else Write('0'); Clock End; Write(' '); End; End; Procedure Lee; Begin For n1:=1 to 32 do Begin Todo[n1]:=0; End; Reset; For Delay2:=1 to Tiempo do Begin; End; GetTime(h,m,seg,frac); Obten; GetTime(h,m,s,hund); Sound(2000);For Espera:=1 to 100000 do Begin;End; Nosound; tseg:=s-seg;tfrac:=hund-frac; If tseg <1 Then tseg:=tseg-65536; If tfrac <1 Then tfrac:=tfrac-65535; GotoXY(40,14); Tarda:=((s+hund/100)-(seg+frac/100)); Writeln(' ',tarda:2:2,'segs '); PintaTodo; End; Procedure Velocidad; Begin GetTime(h,m,seg,frac); For Cont:=1 to 100 do

13

Obten; GetTime(h,m,s,hund); Write (seg:2,'.',frac,' ',s,'.',hund); End; Procedure Introducir; Begin For nlecturas:=1 to 32 do Begin GotoXY(60,5); Write('Byte ',nlecturas,' '); Readln(Todo[nlecturas]); GotoXY(60,5); Write(' '); End; PintaTodo; End; Function Menu:Char; Var op1:char; Begin GotoXY(1,1); Writeln('1 Lee'); Writeln('2 Introducir Números'); Writeln('3 Cambia Delay'); Writeln('4 Velocidad'); Writeln('0 Salir'); Repeat GetTime(h,m,seg,frac); GotoXY(30,1); Writeln(h:2,':',m:2,':',seg:2,'.',frac:2); Until Keypressed; op1:=Readkey; Menu:=op1; End; Begin Tiempo:=5000; Repeat op:=Menu; Case op of '1':Lee; '3':CambiaDelay; '2':Introducir; '4':Velocidad End; Until op='0'; End.

14

Esto nos da una salida de la tarjeta que podemos ver en el Anexo 3. Programa para la Tarjeta: Con esos datos podemos ver que la tarjeta tiene una parte en donde se va grabando y otra donde guarda la información de sus numeros de serie, y tamaño de la misma, por lo tanto se crea el software para emular la tarjeta: Program EmulaDos; Uses CRT, dos; Pin 6 Vcc Pin 7 Vcc Pin 8 Clock Pin 9 Reset Pin 11 Data In Const Start=185 "10111001" reset clock alim alim x 0 TDataIn WE; Reset1=057 "00111001" ; Reset2=121 "01111001" ; Clock1=249 "11111001" ; Writea=250 "11111010" ; Writeb=248 "11111000" ; Start2=187 "10111011" ; Puerto=888; Var Todo:Array[1..128] of Byte; n1,n2,n3,e,x, y, nlecturas:Byte; op:char; CHKSum,Usado,Cont:Byte; tiempo:Longint; Valor,Serie,Espera:Longint; Mal,Cero,Temp:Boolean; h, m, s, hund : Word; For GetTime tseg,tfrac,seg,frac:Word; Delay2:Word; tarda:Real; Procedure Reset; Begin Port[Puerto]:=Reset1; For Tseg:=1 to Tiempo do Begin; End; Port[Puerto]:=Reset2; For Tseg:=1 to Tiempo do Begin; End;

15

Port[Puerto]:=Reset1; For Tseg:=1 to Tiempo do Begin; End; End; Procedure Clock; Begin Port[Puerto]:=Clock1; For Delay2:=1 to Tiempo do Begin; End; Port[Puerto]:=Start; For Delay2:=1 to Tiempo do Begin; End; End; Procedure Escribebit; Begin Port[Puerto]:=Writea; For Delay2:=1 to Tiempo do Begin; End; Port[Puerto]:=Start2; For Delay2:=1 to Tiempo do Begin; End; End; Procedure Borrabit; Begin Port[Puerto]:=Writeb; For Delay2:=1 to Tiempo do Begin; End; Port[Puerto]:=Start; For Delay2:=1 to Tiempo do Begin; End; End; Function Pot(b,p:byte):longint; Var i:byte; t:longint; Begin t:=1; For i:= 1 to p do t:=t*b; Pot:=t; End; Procedure Val; Begin Valor:=0; Valor:=(Todo[9]and 63)*8; Valor:=Valor+(Todo[10]and 224)Div 32; End; Procedure SerieT; Begin Serie:=0; Serie:=(Todo[5] and 31)*Pot(2,26); Serie:=Serie+Todo[6]*Pot(2,18); Serie:=Serie+Todo[7]*Pot(2,10); Serie:=Serie+Todo[8]*Pot(2,2);

16

If Todo[9] and 128=128 Then Serie:=Serie+2; If Todo[9] and 64=64 Then Serie:=Serie+1; End; Procedure CambiaDelay; Begin GotoXY(48,18); Write('Nuevo Delay='); Read(Tiempo); GotoXY(48,18); Write(' '); End; Procedure Credito; Begin Usado:=0; Mal:=False; Temp:=False; Cero:=False; If Todo[13] and 8 = 8 Then Usado:=Usado+1; If Todo[13] and 4 = 4 Then Usado:=Usado+1; If Todo[13] and 2 = 2 Then Usado:=Usado+1; If Todo[13] and 1 = 1 Then Usado:=Usado+1; For Nlecturas:= 14 to 31 do Begin For Espera:= 7 downto 0 do Begin If Todo[Nlecturas] and Pot(2,Espera)<>0 Then Begin Usado:=Usado+1; IF Cero=True Then Mal:=True; End Else Cero:=True; End; End; End; Procedure CHK; Begin CHKSum:=0; For Nlecturas:= 2 to 12 do Begin For Espera:= 0 to 7 do Begin If Todo[Nlecturas] and Pot(2,Espera)<>0 Then Inc(CHKSum); End; End; End; Procedure PintaTodo; Var a,b,t2,t3,t4:byte; Begin For a:= 1 to 8 do Begin; GotoXY(28,a+10); For b:= 1 to 4 do Begin; Write (Todo[(a-1)*4+b]:3,' '); End; End; For a:= 1 to 8 do Begin;

17

GotoXY(13,a+10); For b:= 1 to 4 do Begin t2:=Trunc(Int(Todo[(a-1)*4+b]/16)); if t2>9 Then t4:=t2+55 Else t4:=t2+48; t3:=Todo[(a-1)*4+b]-t2*16; if t3>9 Then t3:=t3+55 Else t3:=t3+48; Write(CHR(t4),CHR(t3),' '); End; End; CHK; GotoXY(48,6); If CHKSum = 216-Todo[1] Then Writeln('CheckSum Correcto') Else Begin Writeln(' ');For Espera:=1 to 100000 do Begin; End;End; SerieT; GotoXY(48,8); Writeln('Serie de la tarjeta:',Serie,' '); Val; GotoXY(48,9); Write('Valor de la tarjeta:',Valor,' '); Credito; GotoXY(48,10); Writeln('Credito Usado:',Usado/2:2:2,' '); GotoXY(48,11); If Todo[32]=255 Then Writeln('Crédito Agotado') Else Writeln(' '); GotoXY(48,13); IF Mal=True Then Writeln ('Error en el área de crédito') Else Writeln (' '); GotoXY(48,15); Writeln('Delay=',Tiempo,' '); End; Procedure Genera; Begin Serie:=0; Randomize; Todo[1]:=0; Todo[2]:=128; Todo[3]:=Random(255); Todo[4]:=Random(255); Todo[5]:=Random(127); Todo[6]:=Random(255); Todo[7]:=Random(255); Todo[8]:=Random(255); Todo[9]:=6; Todo[10]:=76;

18

Todo[11]:=50; Todo[12]:=89; Todo[13]:=240; For n1:=14 to 32 do Todo[n1]:=0; For n1:=2 to 12 do For n2:= 0 to 7 do Begin If Todo[n1] and Pot(2,n2)<>0 Then Inc(Todo[1]); End; Todo[1]:=216-Todo[1]; Pintatodo; End; Procedure Obten; Begin GotoXY(1,20); Port[Puerto]:=Start; For n1 := 1 to 32 do Begin For n2:=1 to 8 do Begin e:=Port[Puerto+1]and 128; If e<>128 Then Begin Write('1'); Todo[n1]:=Todo[n1]+Trunc(Pot(2,8-n2)); End Else Write('0'); Clock End; Write(' '); End; End; Procedure Lee; Begin For n1:=1 to 32 do Begin Todo[n1]:=0; End; Reset; For Delay2:=1 to Tiempo do Begin; End; GetTime(h,m,seg,frac); Obten; GetTime(h,m,s,hund); For Espera:=1 to 100000 do Begin;End; GotoXY(48,14); Tarda:=((s+hund/100)-(seg+frac/100)); Writeln(' ',tarda:2:2,'segs '); PintaTodo; End; Procedure Graba; Var

19

Libre:boolean; seguro:byte; Begin Libre:=false;seguro:=0; Reset; For Delay2:=1 to Tiempo do Begin; End; GotoXY(1,20); Port[Puerto]:=Start; For n1 := 1 to 12 do Begin For n2:=1 to 8 do Begin e:=Port[Puerto+1]and 128; If e<>128 Then Begin Write('1'); Todo[n1]:=Todo[n1]+Trunc(Pot(2,8-n2)); End Else Write('0'); Clock;seguro:=seguro+1; End; Write(' '); End; Repeat e:=Port[Puerto+1]and 128; If e<>128 Then Begin Write('1'); Todo[n1]:=Todo[n1]+Trunc(Pot(2,8-n2)); seguro:=seguro+1; End Else Begin;Libre:=True;End; If Libre <> True Then Clock; Until (libre = true) or (seguro = 255); If seguro=255 Then Begin GotoXY(1,24);Write('Imposible grabar '); End Else Begin;GotoXY(1,24); Reset; For n1:= 1 to seguro-1 do Begin Clock; End; Escribebit; Escribebit; Write(' Bit Escrito ',n1,' '); End; Lee; End; Procedure Velocidad; Begin GetTime(tseg,tfrac,seg,frac); For Cont:=1 to 200 do Obten;

20

GetTime(h,m,s,hund); If tfrac<m Then tfrac:=tfrac+2; Tarda:=((tfrac*60+s+hund/100)-(m*60+seg+frac/100)); Writeln(seg:2,'.',frac,' ',s,'.',hund,' ',tarda:3:2,'segs ',51200/tarda:3:2,' bps '); End; Procedure Borraram; Begin Reset; For Delay2:=1 to Tiempo do Begin; End; GotoXY(1,20); Port[Puerto]:=Start; For n1 := 1 to 12 do Begin For n2:=1 to 8 do Begin e:=Port[Puerto+1]and 128; If e<>128 Then Begin Write('1'); Todo[n1]:=Todo[n1]+Trunc(Pot(2,8-n2)); End Else Write('0'); Clock End; Write(' '); End; For n1:=13 to 32 do Begin For n2:=1 to 8 do Begin Borrabit; Clock; End; End; GotoXY(1,24);Write('Tarjeta Borrada '); Lee; End; Procedure Leemil; Begin For n1:=1 to 128 do Begin Todo[n1]:=0; End; Reset; For Delay2:=1 to Tiempo do Begin; End; GetTime(h,m,seg,frac); GotoXY(1,20); Port[Puerto]:=Start; For n1 := 1 to 128 do Begin For n2:=1 to 8 do Begin e:=Port[Puerto+1]and 128; If e<>128 Then Begin Write('1');

21

Todo[n1]:=Todo[n1]+Trunc(Pot(2,8-n2)); End Else Write('0'); Clock End; Write(' '); End; GetTime(h,m,s,hund); For Espera:=1 to 100000 do Begin;End; GotoXY(40,14); Tarda:=((s+hund/100)-(seg+frac/100)); Repeat Until Keypressed; ClrScr; End; Procedure Introducir; Begin For nlecturas:=1 to 32 do Begin GotoXY(60,5); Write('Byte ',nlecturas,' '); Readln(Todo[nlecturas]); GotoXY(60,5); Write(' '); End; PintaTodo; End; Procedure Leetarjeta; Begin Lee; GotoXY(1,24);Write('Tarjeta Leida '); End; Procedure Emula; Pin 4 Data Out (PC -> Phone) 4 Pin 12 Data In 32 Pin 13 Reset 16 Pin 15 Clock 8 Var Sal:Char; By,Bi,Edo,Edoa,Tpo:Byte; Begin GotoXY(1,24);Write ('*****************Emulando*****************'); By:=1;bi:=7; Edo:=Port[Puerto+1] And 56; Tpo:=Todo[By] And Pot(2,bi); If Tpo<>0 Then Tpo:=4 Else Tpo:=0; Port[Puerto]:=Tpo;

22

Repeat Repeat Edo:=Port[Puerto+1]and 56; Until Edo<>Edoa; Edoa:=edo; If Edo=24 Then Begin; If bi=0 Then Begin; By:=By+1;bi:=7;End Clock Else bi:=bi-1; If By=33 Then By:=1; End; If Edo=8 Then Begin;By:=1;bi:=7;End; Reset If Edo=40 Then Begin; Write If By>12 Then Todo[By]:=Todo[By] or Pot(2,bi); End; Tpo:=Todo[By] And Pot(2,bi); If Tpo<>0 Then Tpo:=4 Else Tpo:=0; Port[Puerto]:=Tpo; Until keypressed; End; Procedure Apaga; Begin Port[Puerto]:=0; GotoXY(1,24);Write('Tarjeta Apagada '); End; Function Menu:Char; Var op1:char; Begin GotoXY(1,1); Writeln('1 Genera Numero De Serie'); Writeln('2 Introducir Números'); Writeln('3 Cambia Delay'); Writeln('4 Velocidad'); Writeln('5 Graba'); Writeln('6 Lee'); Writeln('7 Lee 1024'); Writeln('8 Apaga'); Writeln('9 Emula'); Writeln('0 Salir'); Repeat GetTime(h,m,seg,frac); GotoXY(30,1); Writeln(h:2,':',m:2,':',seg:2,'.',frac:2); Until Keypressed; op1:=Readkey; Menu:=op1; End;

23

Begin Clrscr; Tiempo:=500; Repeat op:=Menu; Case op of '1':Genera; '3':CambiaDelay; '2':Introducir; '4':Velocidad; '5':Graba; '6':Lee; '7':Leemil; '8':Apaga; '9':Emula; '0':Apaga End; Until op='0'; End.

24

Conclusiones: El hardware creado y el software corren sin ninguna complicación, el teléfono público detecta la tarjeta, y permite la marcación mas al tratar de cargar el crédito existe un problema con la sincronización entre el aparato telefónico y el hardware, al parecer existe un delay de seguridad o un segundo reloj que hace imposible hacer que se genere la tarjeta.

25

ANEXO 1 Emulador de tarjetas PROM.

José Manuel García Introducción En la actualidad, está muy extendido el uso de las llamadas tarjetas chip. Esta denominación incluye varios tipos de tarjetas cuyas únicas características comunes son el tamaño (tipo tarjeta de crédito) y la inclusión de un chip en lugar de una banda magnética como medio para almacenar datos. Por lo demás, las tarjetas chip pueden estar destinadas a usos muy diversos, y los chips que utilizan pueden ir desde una simple PROM hasta sistemas basados en microcontroladores capaces de codificar y almacenar datos con altos niveles de seguridad. En este estudio se tratan de forma específica las tarjetas PROM a nivel teórico y práctico, y la manera de construir un circuito simple que sea capaz de emular el funcionamiento de una tarjeta original. Si bien se podría haber conseguido esto con un solo microcontrolador programable, he optado por un diseño algo mayor, pero más fácil de construir, ya que no requiere de un programador o un grabador de EPROMs, ni de ajuste alguno para su construcción y puesta en funcionamiento.

Tarjetas PROM Las tarjetas PROM más habituales contienen en su interior una PROM de 256 bits, organizados en 256 direcciones de 1 bit. El direccionamiento de dicha PROM lo realiza un circuito contador de 8 bits, de forma que cuando el contador está en la dirección n, podemos leer o escribir en dicha posición n. Para avanzar a la siguiente dirección, sólo hay que darle un impulso a la entrada de reloj del contador, y entonces, éste apuntará a la siguiente dirección, n + 1.

Existe además una entrada de reset que pone a cero el contador. Además, el contador de direcciones es cíclico, de forma que si está en la posición 20 y queremos acceder a la 18, podemos hacer un reset y dar 18 pulsos de reloj, o bien no utilizar el reset y dar 254 pulsos de reloj. En la figura 1 aparece la numeración de las patillas de un chip de tarjeta PROM estándar, y en la tabla

1 el significado de cada patilla o contacto. En la figura 2 se puede ver la cronología de las señales para un ciclo de reset, de lectura o de escritura. Durante un reset, Vpp debe estar a +5V, el estado de Din es indiferente, y RST debe estar a cero. En estas condiciones, durante el flanco de bajada de CLK, se pone a cero el contador de direcciones interno. Para el resto de operaciones, la patilla RST debe estar a nivel alto. En estas condiciones, una vez hecho un reset, tendremos en Dout el dato almacenado en la dirección 0 de la PROM. Si ahora damos un pulso de reloj, cuando CLK vuelve a estado bajo, tendremos en Dout el dato de la dirección 1 de la PROM, y así sucesivamente, hasta llegar a 255, en que volvería a la dirección 0. Si durante un pulso de reloj Vpp está puesto a +21V, el estado de Din quedará almacenado en la dirección de la PROM que indicara el contador interno. A este respecto, es conveniente aclarar un par de cosas: una PROM en blanco, o virgen, tiene almacenadas en todas sus direcciones ceros. Podemos convertir uno de esos datos en un 1, pero jamás podremos poner un cero donde había un 1. Por tanto, si durante un ciclo de escritura en Din hay un cero, el contenido de la PROM no variará. Por otro lado, la PROM de las tarjetas comerciales, tiene una zona “reservada”, en la que no se puede escribir. Esta zona ocupa las 96 primeras

Patilla: Significado: 1 GND: Masa lógica. 2 Vpp: Tensión de programación (+21V). 3 Dout: Salida de datos. 4 No utilizada. 5 RST: Reset (activo a nivel bajo). 6 CLK: Clock (activo en flanco de bajada). 7 Din: Entrada de datos. 8 Vcc: Alimentación (+5V).

Fig. 1.

Tabla 1.

Fig. 2.

26

direcciones de la PROM, y ha sido escrita en fábrica y protegida fundiendo un fusible interno. En esta zona reservada, están almacenados datos acerca del fabricante, el tipo de tarjeta, la empresa para la que ha sido fabricada, valor de la tarjeta y nº de serie. El resto de direcciones suelen contener ceros, aunque en algunas tarjetas, algunas direcciones, normalmente de la 96 a la 105, o bien de la 246 a la 255, han sido puestos a 1 durante el control de calidad en fábrica. Cuando una tarjeta es introducida en un lector, éste lee la zona reservada y comprueba si la tarjeta es de esa empresa y de qué valor es. Si la tarjeta es válida, va leyendo el resto de la tarjeta para averiguar hasta donde ha sido escrita y calcula cuánto le queda por gastar. Conforme se van gastando pasos, el lector va poniendo a 1 direcciones de la PROM y leyéndolas para verificar que han sido bien escritas, hasta llegar a una dirección determinada en que calcula que la tarjeta está completamente agotada. Emulador Lógicamente, para emular una tarjeta PROM tendremos que realizar un circuito capaz de responder como una tarjeta real, pero si queremos que sea reutilizable, deberá ser posible borrarla, es decir, hacer que siempre que la introduzcamos en un dispositivo de lectura, se comporte como una tarjeta nueva. Por tanto, nuestro emulador deberá responder a la lectura de los primeros 96 bits como lo haría una tarjeta real, y deberá permitir que se escriba y se lea en el resto, almacenando los valores escritos hasta que nosotros queramos, o, al menos, durante el rato que dure su utilización. Nuestro emulador ha sido diseñado de acuerdo con esta idea, es decir, con las siguientes especificaciones: debe responder en las primeras 96 direcciones (0 - 95) como una tarjeta estándar, y en el resto (96 - 255), debe responder con 0 mientras no se escriba otra cosa (como si fuera una tarjeta recién comprada), y cuando se escriba un 1 en una dirección, ese dato debe poder ser leído en sucesivas operaciones de lectura. Además, debe responder ante un ciclo de RESET como lo haría una tarjeta real, es decir, inicializando el contador de direcciones a 0, pero sin que se borre el contenido de dichas direcciones de memoria. Como primera aproximación, nuestro emulador consta de los siguientes bloques: - Un circuito contador; se encargará de ir contando como lo haría el contador interno de una tarjeta comercial, para que nuestro circuito “sepa” cuál es la dirección en la que el dispositivo lector va a escribir o leer, y cuándo está en la zona reservada y cuándo no. El chip encargado de esta función es un 4040. - Una ROM de 96 bits, conteniendo una copia exacta de los primeros 96 bits de la tarjeta que se quiere emular. La ROM más barata y que mejor se ajusta a estas características es el propio chip de una tarjeta comercial (puede ser usada, puesto que el contenido de esta zona reservada no varía de una tarjeta nueva a una gastada). - Una memoria RAM estática de, al menos, 160 bits; se encargará de almacenar los datos que vaya escribiendo el lector, como si fuera una PROM, pero con la diferencia de que puede ser borrada. Para esta función se ha elegido un chip de tipo 4537, una RAM en tecnología CMOS de 256 bits. - Un decodificador de direcciones que asegure que en las primeras 96 direcciones funcione nuestra ROM y en el resto nuestra RAM. En nuestro circuito, esta función la realizan un par de puertas. Como se podrá observar, aparte de la tarjeta usada, el resto de componentes no cuesta más de 500 pesetas. Diseño práctico En la figura 3 se puede ver el esquema del emulador. Para explicar su funcionamiento, veremos qué componentes intervienen en cada una de los tres tipos de operaciones que debe realizar, reset, lectura y escritura, así como el funcionamiento en el momento de la desconexión de la fuente de alimentación externa (proporcionada por el propio dispositivo lector). Durante un ciclo de reset, IC1 pone su contador interno a 0, puesto que sus patillas 5 y 6 están directamente conectadas a las patillas 5 y 6 de CON1. El reseteo de IC5 es algo más complejo. El conjunto formado por R1, R2 e IC2C, se encarga de que en la salida de IC2C haya un 1 siempre que la tensión de programación (+21 V) esté desactivada en la patilla 2 de CON1. En estas condiciones, si en la patilla 6 de CON1 aparece un 1, en la salida de IC3A habrá también un 1. El conjunto formado por D4, D5 y R4, actúa como una puerta AND, y el conjunto de T1 y R5 como un inversor. En estas condiciones, al pasar a nivel bajo la patilla 5 de CON1, en el cátodo de D4 aparece un 1 y , por tanto, en el ánodo de D4 y D5 aparece un 1, lo cual hará que IC5 se resetee. El conjunto de R6 y C2 tiene por objeto retrasar el pulso de RESET un poco respecto al de CLOCK, para evitar que una vez reseteado IC5, durante la caída de la señal de reloj, cuente un paso.

27

Fig. 3

28

En los ciclos de lectura, IC3D y la puerta OR formada por D2, D3 y R3, actúan como decodificador de direcciones, de forma que en el cátodo de D2 y D3 aparece un 1 cuando el valor del contador IC5 es mayor que 95, y un 0 si el valor del contador está en el rango de 0 a 95. El conjunto formado por IC2A, IC2B, IC3B, IC3C e IC2D actúa como un puerto de dos entradas y una salida, de forma que en las direcciones de 0 a 95 los datos se lean de IC1 y en las direcciones de 96 a 255 se lean de IC4. Durante un ciclo de escritura, siempre se escribe en la RAM (IC4), y el conjunto formado por R1, R2 e IC2C se encarga de generar la señal de Write Enable para IC4 a partir de la tensión de programación (Vpp). Cuando se desconecta la tensión de alimentación del circuito (al extraer el emulador del lector de tarjetas), el conjunto formado por D1 y C1 actúan como una pequeña alimentación de emergencia. El motivo de incluir este dispositivo es evitar que en un pequeño corte de la alimentación se pierdan los datos almacenados en IC4. Con los valores descritos, los datos persistirán en la RAM durante unos segundos (depende del modelo usado para IC4), al cabo de los cuales se borrarán, quedando el emulador en condiciones de volver a usarse. En caso necesario, se puede incluir un pulsador que cortocircuite C1 a través de una resistencia de 100 ohmios, para provocar un borrado manual. Construcción Para la construcción del emulador se ha diseñado el circuito impreso de la figura 4. Como puede observarse, alberga todos los componentes, incluido el chip de una tarjeta usada. Debido al pequeño grosor de las tarjetas comerciales (0.8mm ±0.1mm), será necesario utilizar placa de circuito impreso flexible de una sola cara, en la que se efectuará el trazado de las pistas por el método que se prefiera, pero respetando especialmente la forma en la zona que actuará como conector del emulador. Antes de insertar y soldar los componentes, es importante dar la forma adecuada a sus patillas para evitar que deformen la placa. Se utilizará un soldador de poca potencia (menos de 25W) con toma de tierra, para evitar daños a los circuitos integrados. Si no se dispone de soldador con toma de tierra, es recomendable utilizar zócalos para dichos circuitos integrados.

29

En la figura 5 está la lista de componentes empleados. Empezaremos por soldar los ocho puentes, para los que se utilizará cable de pequeña sección con funda aislante (es muy importante colocar los puentes antes que el resto de componentes, ya que algunos quedarán debajo de IC3 e IC4). A continuación soldaremos las resistencias y los condensadores, teniendo en cuenta que C1 tiene polaridad. Después los diodos, prestando atención a la posición de la marca; D2 debe soldarse de forma que permita posteriormente insertar el circuito integrado IC3. A continuación se soldará el transistor T1. El siguiente componente es el chip de una tarjeta usada, pero antes de soldarlo a la placa debemos prepararlo. Recortaremos de una tarjeta usada, sólo el cuadrado que incluye el chip y los ocho contactos, ya que el resto de la tarjeta es sólo plástico. Colocándolo sobre una superficie metálica que facilite la disipación de calor, soldaremos lo más rápido posible (para evitar que se caliente en exceso), un hilito de cobre a cada patilla, lo más cerca posible del borde del cuadrado. Pegaremos con pegamento el chip en su sitio (por la cara de plástico, es decir, con los contactos hacia arriba), y soldaremos los hilos a la placa de circuito impreso. Por último, soldaremos los circuitos integrados, dejando para el final IC4, por ser el más sensible (nótese que IC4 va en distinta postura que el resto de los circuitos integrados). Una vez terminado, es muy importante proteger el circuito para que la cara de cobre no haga contacto con el chasis del lector de tarjetas. Para ello, pegaremos una lámina de plástico adhesivo (lo venden en papelerías) por la parte de las pistas de cobre, con cuidado de que no haga burbujas, y quede perfectamente liso, al menos en la parte que se introducirá en

Fig. 4Lista de componentes:

IC1: Chip de tarjeta usada. IC2: 4001 IC3: 4081 IC4: 4537 IC5: 4040 T1: BF320 D1-D5: 1N4148 R1, R3, R4: 10K (0.25W) R2: 2K2 (0.25W) R5: 470Ω (0.25W) C1: 10µF 16V C2: 100nF

Fig. 5

30

el lector. Una vez pegado, cortaremos y retiraremos el cuadrado correspondiente a la zona que hará de conector (esta operación se debe hacer con cuidado para no dañar las pistas de cobre o la propia placa de circuito impreso). En el prototipo, añadí además una lámina de plástico (la recorté de un separador de un bloc) pegada sobre la cara de componentes, para aproximar el grosor del emulador al de una tarjeta real (unos 0.8mm), y, al mismo tiempo, darle más rigidez. Notas finales En el diseño no se ha previsto un circuito de puesta a cero de la memoria RAM, debido a que en las pruebas, con una RAM de tipo MCM14537AL, todas las direcciones se ponían a 0 espontáneamente al alimentarla. Sin embargo, no hay garantía de que otros modelos se comporten igual, por lo que, dentro de lo posible, es recomendable utilizar ese modelo en concreto. Por último, hay que hacer hincapié en que el circuito sólo debe utilizarse con fines experimentales, y en ningún caso con fines lucrativos ni comerciales. El utilizarlo en equipos de pago automático puede ser constitutivo de delito.

31

Anexo 2 Información de las Tarjetas Telefónicas.

Por Merlín.

Acerca de los teléfonos Desde hace unos cuantos años hasta ahora, nuestra querida Telefónica nos a venido sorprendiendo con unos

nuevos telefonines públicos (cabinas), equipados con lector de tarjetas. Dichas tarjetas, como todos sabréis, están equipadas de un chip, una memoria PROM, imposible de borrar una vez escrita. Por lo que la idea de hacer un “recargador” de tarjetas fue rechazada de cuajo. Sin embargo, hace ya unos años, surgió la idea de emular la susodicha memoria PROM, y de este modo disponer de una tarjeta válida, y con la posibilidad de puesta a cero en cada llamada. Surgieron varios circuitos con este fin, unos antes, otros después, otros mejores, otros peores. Pero desde hace un tiempo (año y medio aproximadamente), los inventos dejaron de funcionar, las cosas empeoraron y surgió la controversia, de tal forma que construir un emulador actualmente se ha convertido en una cosa muy chunga . Y aquí está este documento, con la idea de aclarar ideas más que exponerlas, en el difícil mundo del phreaking en España. Desde CPNE esperamos aclara tus dudas.

Acerca del patillaje de las tarjetas.

Recientemente, si el phreaker intrépido lee los diversos documentos referentes a tarjetas telefónicas(

Bausson, TPROM.DOC, Ingenieros Cabreados, Lector por _J-R_ y SpeedFire, Emulador de Minotauro/DAN), se dará cuenta que no existe coherencia entre ellos. Eso es así porque cada DOC. llama a los pines de una manera distinta, e incluso se le otorgan distintas funciones. ¿Cuál elegir? Porque evidentemente, alguien dirá la verdad. Voy a tratar de explicar quien y quien no tiene la razón y por qué. NOTA: puede que yo también me equivoque.

Observa la figura 1. Fíjate bien, porque esa es la numeración de pines que

seguiré en este documento. Ojo, porque puede no coincidir con los otros autores. La tabla 1 expone el patillaje y las funciones de los pines según JM García y su TPROM.DOC. GND y Vcc corresponden a la alimentación. Vpp se usa para programar una dirección de la memoria. Dout es la salida de datos de la posición de memoria

actual. Din es la entrada de datos. Cuando Vpp == 21V, el estado de Din quedará grabado en la posición apuntada por el contador interno. Recordemos que sólo se pueden grabar unos. CLK sirve para cambiar de dirección el contador interno, de tal manera que recorre cíclicamente los 256 bits de manera secuencial. RST sirve para poner a cero el contador interno y que este apunte a la dirección 0 (como en C, la primera dirección es la 0, no la 1). La figura 2 muestra el diagrama de tiempos según el TRPOM.DOC también. Como se ve, la tarjeta tiene 3 posibles estados: Lectura, Reset y Escritura. Comencemos con el ciclo de reset. Considerando que el contador esté en la posición n, si ponemos RST a nivel bajo y DAMOS UN PULSO DE RELOJ, el contador apuntará a la posición cero, y por lo tanto, por Dout saldrá el dato grabado en la posición 0. Hay que decir que si no damos el pulso de Reloj, no se producirá el RESET. Estando leyendo una posición Dn, si aplicamos un pulso de reloj, el contador avanzará una dirección, y por Dout saldrá el dato que esté grabado en Dn+1. El ciclo de escritura es el más complejo: Estando el contador en Dn, pondremos en Vpp 21v y Din a uno( recuerdo que sólo se pueden grabar unos), y aplicaremos un pulso de reloj y retiraremos Din y Vpp a 5V. El contador NO AVANZARÁ y quedará grabado en Dn un 1. Para poder leer la siguiente posición, habremos de aplicar otro pulso de reloj. Es importante dejar claro que JM expone que el estado de Dout es irrelevante en las operaciones de escritura. Vpp deberá estar conectado a +5v siempre, menos en las operaciones de programación cuando esté a 21v. En ningún momento debe estar a 0v.

Fig. 1

Patilla: Significado 1 GND: Masa lógica 2 Vpp: Tensión de Programación 3 Dout: Salida de datos 4 no utilizada 5 RST: Reset 6 CLK: Reloj 7 Din: entrada de datos 8 Vcc: Alimentación (+5v)

Tabla 1

32

Explicaremos ahora lo que dice

el señor Bausson en su Doc. sobre las smartcards. Para el señor Bausson, los pines tienen idéntica función, salvo los siguientes: Dout (pin nº 3) es llamado I/O, es decir, entrada y salida de datos. Esto es importante, pues por este pin saldrán los datos que leamos, pero TAMBIÉN ENTRARÁN los que queramos grabar. Din (pin nº 7) es llamado por Bausson, R/W, es decir, estando a nivel bajo, la tarjeta estará en modo de lectura y estando a nivel alto, en modo de escritura. La figura 3 muestra el diagrama de tiempos propuesto por Bausson. Señalo que hay contradicciones en el documento de Bausson: dice que el pin 3 es de I/O. Si sólo se pueden grabar unos, en un ciclo de programación deberá estar a uno. Sin embargo, en su

diagrama de tiempos pone que su estado es irrelevante (o sea, que da lo mismo como esté para que se produzca la grabación). Aquí coincide con JM García. Otro dato importante es que mientras JM expone que durante la grabación el contador no avanza, según Bausson si. Resumiendo-> de la doc de Bausson se saca que coincide con JM García, salvo en lo del contador que se incrementa en la grabación. Lo demás es lo mismo, pero con distinto nombre. Esto es haciendo caso a los diagramas de tiempo.

Pero… ¿cuál tiene razón?. Pues ninguno de los dos. Leyendo en Bausson el mapa de memoria, las tarjetas españolas son fabricadas por: Gemplus, Oberthur y G+D. Gemplus es una importante compañía, pero que no da información. G+D me es desconocida (al menos por ese nombre). Oberthur es una división de KirkPlastic, y en su web encontré que las tarjetas que fabrican incorporan el chip ST1200. ST es de SGS-THOMSON, importante empresa de semiconductores. El chip ST1200 se corresponde efectivamente con una memoria EPROM de 8 pines, de 256 bits, con todo lo expuesto en orden. Todas los pines coinciden, salvo el pin 5 ( Reset) y el 7 (Din según JM y R/W según Bausson). En el datasheet, el pin 5 es B y el 7 es A, mientras que CLK es un reloj que valida los códigos de función que ingresemos por A y B. Es decir, que cuando demos un pulso de Reloj,

dependiendo de los cuatro estados posibles de A y B ( porque son 2 bits, 4 combinaciones), se producirá: o una lectura, incrementando el contador, o una escritura ( luego explico si incrementando el contador o no), o un reset. Es lo mismo, pero con otro nombre. La tabla 2 muestra estos códigos. Como se ve, el pin B ( nº 5) bien puede corresponderse con un reset, activo a nivel bajo. Y el pin A puede corresponderse con un R/W. El chip asume que sólo se escriben unos. En el datasheet, el pin 3 ( Dout

según JM y I/O según Bausson) es Dout, con lo que Bausson está confundido. De todas formas, el diagrama de Bausson está bien en este aspecto. Y vamos con lo más escabroso-> ¿avanza el contador de direcciones en un ciclo de programación? Según el datasheet, NO, no avanza. Luego la razón la tiene JM García, pero ojo, sólo para las tarjetas que lleven el chip ST1200, que son las de Oberthur. Es posible que las de Gemplus también los lleven. Las de G+D NO lo llevan ( asique no se te ocurra intentar emularla con estos datos). Las ilustraciones de la página siguiente muestran los diagramas de tiempos de el ST1200. Para poder leerlos, adjunto todo lo necesario. Espero que ahora las cosas estén un poco más claras. Y estos son los pines que propongo: todos iguales que JM García ( GND, Vpp, Dout, RST, CLK y Vcc) salvo Din, que llamaremos R/W, como Bausson. En cuanto a diagrama de tiempos, el de JM García y los del ST1200 son los únicos válidos.

Fig. 2

Fig. 3

A B Modo 0 0 Pone a cero el contador ( Reset) 0 1 Incrementa el contador 1 1 Programa la celda de memoria 1 0 prohibido

Tabla 2

33

Por el bien de todos los phreakers, no divulguéis más información falsa. Es conveniente usar todos la misma terminología.

La Emulación. Hace ya unos cinco años que apareció el primer emulador de tarjetas PROM ( o EPROM, mejor). Fue el TPROM.DOC de Don JM García. El emulador funcionaba a la perfección ( yo no lo he probado) hasta hace año y medio ( estando ahora a Septiembre del 97). Muchos son los que se han aventurado a predecir las causas de esto, pero una cosa está clara: tiene que haber forma de hacerlo funcionar. El usuario que se ponga a construir el susodicho emulador, se encontrará que ciertos componentes (concretamente la memoria, una CMOS 4537, y el transistor, el BF320) se han quedado obsoletos y ya no se fabrican. Además, como ya he dicho, el emulador NO FUNCIONA en las actuales cabinas (y me refiero a las azules de toda la vida). El propio autor propuso que se debía a cortes en la alimentación, pero de ser así, bajaría el pestillo, jodiéndose el invento a media llamada. Pero según las últimas informaciones, el pestillo ni siquiera se baja, con lo que esa no es la causa(o por lo menos, no esa sola). Por lo que he oído, el teléfono, modernamente, sólo alimenta la tarjeta(o el emulador) cuando descuenta

dinero(quema fusibles). Sin embargo, al principio, la alimenta hasta que la lee y baja el pestillo. Debería bajarse el pestillo. Y no se baja. Pensando mucho, después de ver el convertidor de tarjetas de 1000 a 2000 ptas. de Cyberhack Magazine(seguid así muchachos), y si es verdad que funciona, deduzco que el fallo está a partir de la dirección 96. Pregunta ->¿qué tiene una tarjeta real después del bit 96 que no tenga el emulador(cualquiera de ellos, el de JM y el de ingenieros, del que hablaré más adelante)? Pues si. Los DIEZ FUSIBLES FUNDIDOS de fábrica. Haré pruebas para confirmarlo, aunque creo que esa es la causa de que el emulador falle. Esto es así porque es fácil para Timofónica desarrollar un nuevo software para su módulo lector de tarjetas que compruebe que las diez siguientes direcciones a la 96 están a 0 (debiendo estar a 1). Ni siquiera tiene que cambiar el lector. Sólo el software( y por lo que he oído, lo puede cambiar a distancia por el módem que incorporan los TMs). En fin, alguien debería actualizar este emulador, poniendo memorias actuales ( 6116, 6264) y a base de puertas, no transistores, respetando el diagrama de tiempos(no como los ingenieros cabreados) y corrigiendo el fallo de los diez fusibles. Si piensas construirlo, despídete, pues aunque consigas todos los componentes, NO FUNCIONA tal y como está ahora en el TPROM.DOC.

34

Otro emulador interesante aparecido recientemente es el de Ingenieros en Paro Cabreados. Está realizado por un tal Jack el Destripa-Hardware, y se intenta que sea el sucesor del TPROM.DOC. Está realizado con componentes modernos, que se encuentran en todas las tiendas de electrónica, y su realización práctica es posible. Sin embargo….. NO FUNCIONA. En efecto, no funciona. Y esto es, además de por lo de los diez fusibles que he comentado, porque tiene fallos en el diseño. En una tarjeta real, el Reset, se produce al darle un pulso de CLK con la señal de Reset activada, pero en el emulador el Reset se produce con sólo activar el Reset, sin tener en cuenta el pulso de Reloj. Creo que este error no es crítico(es decir, es error, pero que no impide que el trasto no funcione, pues si se activa el reset, se entiende que el teléfono mandará el correspondiente CLK). De todas formas, uno ya no se puede fiar ni de su sombra, y si queremos un chisme que funcione…. Otro fallo está en la escritura. Hemos quedado que en la tarjeta real, cuando R/W (según mi terminología, no la de Bausson) está a uno y Vpp a 21v, si se produce el pulso de reloj, queda grabado un uno en la posición Dn, y el contador NO AVANZA, por lo que inmediatamente leeremos el Dn, sin necesidad de resetear la tarjeta. El emulador no tiene en cuenta esto, y avanza a la siguiente posición, con lo que el teléfono rechazará la tarjeta(en este caso nuestro invento). Este es un error crítico, que hace que el emulador NO FUNCIONE. No lo hagas, pues NO FUNCIONA. Hay que revisarlo también. Otro emulador apareció en la revista Minotauro. Está hecho a base de microcontrolador y emula a una tarjeta GASTADA, por lo que habría que cambiar el código del micro. No lo he probado ni lo pienso probar, porque creo que es una tontería(pues encima de usar componentes caros, emula a una tarjeta GASTADA). No lo hagas(aunque aporta ideas muy buenas). Por último, de los emuladores que conozco, sólo me queda hablar del de Lionel Hutz. Es una quedada, no vale para nada. No hay más que mierda en ese DOC. Ni lo mires. Cualquiera que sepa un poco de electrónica dirá: ¿qué kojones es esto?. En efecto. Una auténtica BOBADA. Si llega a tus manos, bórralo. En resumen, actualmente (septiembre-1997) no hay emulador que funcione en las cabinas azules. Despídete de construir nada(por ahora) y no enriquezcas a los dueños de las tiendas de componentes electrónicos. Sin embargo, en la revista CyberHack Magazine ha aparecido un convertidor de 1000 ptas a 2000 o 2100 ptas. Dicen que funciona(todavía no me ha dado tiempo a probarlo). Creo que es factible que funcione. Abre una puerta a la esperanza a los que intentamos hacer un emulador a base de componentes, es decir, sin usar microcontrolador. Otro proyecto, que se debería intentar por gente experta(mis conocimientos de electrónica son de nivel básico), es un emulador a base de un PIC16C84. Llevaría el PIC, un cristal y un condensador, y cabría en la propia tarjeta. Lo jodido es diseñar el programa del microcontrolador. Yo mismo lo haría, pero no tengo ni puta idea de microcontroladores. Ya sabréis lo que hay que emular, y cómo. Pues hala, hala… Para más datos del chip, id a la web de SGS. Y para el mapa de memoria, lo mejor es recurrir a Bausson. Y EMULAD TARJETAS Oberthur, que son las que sabemos que con seguridad tienen el ST1200. Hay que respetar todos los ciclos del diagrama de tiempos. También sería interesante que el programa del PIC cambiara el nº de serie de la tarjeta cada llamada, poniéndolo al azar, o siguiendo cualquier algoritmo que lo cambiara. Habría que recalcular el checksum también. Esto se puede hacer si el PIC tiene memoria EEPROM(que creo que si). Tendríamos el emulador perfecto. Os pongo una “bibliografía” de todos los DOCs de terceras partes mencionados aquí. La mayoría los podrás encontrar en la CPNE, y en los lugares habituales de phreaking en español. Te recomiendo que te los pilles: TPROM.DOC, por JM García. Emulador de Ingenieros en paro Cabreados. Cyberhack Magazine, por Cy. Minotauro Magazine. Emulador de TT por Lionel Hutz. What do you need to know about smartcards, por Stephane Bausson, versión 1.20. Las Smartcards, por _J-R_ y Speedfire. Y por último, pero no por ello lo menos importante, esto: Este documento está hecho con fines totalmente didácticos. No me responsabilizo del uso fraudulento o ilegal de los datos aquí expuestos. Merlín.

36

Anexo 3

Salida de una Tarjeta Telefónica. BYTE 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 30 31 32 0 0 1 2 3 6 6 7 8 9 9 0 8 6 4 5 5 6 4 7 5 9 VAl serie CHKSUM PAIS | SERIE | | VALOR | UNIDADES | CREDITO $100 0575721376 10110111 10000000 10001110 01100000 011 01000 10010100 00110011 11101000 00 000110 010 01100 01100100 01011001 1111 1111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 00000000 00000000 00000000 00000000 00000000 00000000 00000000 183 128 142 96 104 148 51 232 6 76 100 89 255 255 255 255 255 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 $50 0306707762 10110010 10000000 10000101 11110010 010 00100 10010001 11111111 01001100 10 000110 010 01100 00110010 01011001 1111 1111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 00000000 00000000 00000000 00000000 00000000 00000000 00000000 178 128 133 242 68 145 255 76 134 76 50 89 255 255 255 255 255 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 $50 0162505334 10110011 10000000 11101000 01100010 010 00010 01101011 11101000 10011101 10 000110 010 01100 00110010 01011001 1111 1111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111100 00000000 00000000 00000000 00000000 00000000 00000000 00000000 179 128 232 98 66 107 232 157 134 76 50 89 255 255 255 255 255 255 255 255 255 255 255 255 252 0 0 0 0 0 0 0 $30 0231311112 10110110 10000000 10101011 00100110 000 00011 01110010 01100001 11000010 00 000011 110 01100 00110010 01011001 1111 1111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 11111111 182 128 171 38 3 114 97 194 3 204 50 89 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0 0 0 0 255 $30 0416787456 10110011 10000000 11101001 11010110 010 00110 00110101 11101011 00000000 00 000011 110 01100 00110010 01011001 1111 1111 11111111 11111111 11111111 11111111 11000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 179 128 233 214 70 53 235 0 3 204 50 89 255 255 255 255 255 192 0 0 0 0 0 0 0 0 0 0 0 0 0 0 $30 0244248247 10101101 10000000 10001111 01100101 010 00011 10100011 10111011 10101101 11 000011 110 01100 00110010 01011001 1111 1111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 11111111 173 128 143 101 67 163 187 173 195 204 50 89 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0 0 0 0 255 $20 0012417530 10110011 10000000 10100001 01011101 000 00000 00101111 01011110 01111110 10 000010 100 01100 00110010 01011001 1111 1111 11111111 11111111 11111111 11111111 11110000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 11111111 179 128 161 93 0 47 94 126 130 140 50 89 255 255 255 255 255 240 0 0 0 0 0 0 0 0 0 0 0 0 0 255 $20 0056331345 10110011 10000000 11100010 01111111 010 00000 11010110 11100011 00010100 01 000010 100 01100 00110010 01011001 1111 1111 11111111 11111111 11111111 11111111 11110000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 11111111 179 128 226 127 64 214 227 20 66 140 50 89 255 255 255 255 255 240 0 0 0 0 0 0 0 0 0 0 0 0 0 255