Tarea2:

 La tarea 2 es checar si las claves que genera nuestro otp (one time pad) realmente es aleatoria.

 La clave evaluada fue la siguiente:


Esta clave es generada del programa anterior con el siguiente código:

	def generar_claves():
	k=''
	for m in range(10):
	s = binary(randint(0,255))
	k += s
	return k

view raw g.py hosted with ❤ by GitHub

Funciona leyendo las claves del archivo llamado key.txt pasandoselo a cada uno de los test.

	def leer_archivo(archivo,test):
	archivo = open(archivo, 'r')
	numero=''
	for i in archivo.readline().strip():
	numero+=i
	# print numero
	#print (len(numero))
	if test==3:
	print numero
	return numero
	else:
	numero = map(int,numero)
	numero = array(numero)
	return numero

view raw leer.py hosted with ❤ by GitHub

Primero yo realice un test sencillo que se llama Monobit:

Monobit

Detecta los ceros y los unos que se encuentran en la cadena binaria, sustituyendo los ceros que encuentre por -1, asi realizando una suma. La aparición de ceros y unos en la secuencia global deberan de ser igualmente probables

Datos a tener:

n = tamaño de la clave binaria
ε =La secuencia de bits que se esta probando

Procedimiento:

1. Como mencione se buscan los ceros y se sustituyen por -1y se realiza una suma, ejemplo:
   lista=[1,1,0,0,1,0,1]
   quedaría:
   lista=[11,-1-1,1-11]
 y se realiza la suma de la lista

2-Se calcula la prueba estadística:

3. Se calcula p_value ( erfc es la función error complementaria.)

4.Si P - value > 0.01, la secuencia  es aleatoria.

Código:

	def monobit(lista):
	print 'Test Monobit'
	n=len(lista)#tam de lalista
	for m in range(n):# recorre la lista
	if lista[m]==0:
	lista[m]= -1 # Si encuentra un 0 en la lista lo hace -1
	sn=sum(lista) # realiza la suma
	s_obs=abs(sn)/math.sqrt(n) #calcula prueba estadistica
	p_value= math.erfc(s_obs/math.sqrt(2)) #calcula p_value
	if p_value > 0.01:
	print ">> Frequency Test: PASSED -->", p_value
	else:
	print ">> Frequency Test: NOT PASSED --> ", p_value

view raw monobit.py hosted with ❤ by GitHub

Captura de pantalla de la prueba:

También utilice otras dos pruebas que es la de Poker y la de frecuencia de Bloques

Frecuencia de Bloques

En la prueba de bloques los ceros y unos deberan de ser igualmente probables.
 Datos:

n - largo de la secuencia
m - el largo de cada bloque
ε - secuencia de bits generada

Recomendaciones:

Procedimiento:

1. Se parte la prueba e bloques de un cierto tamaño se calcula de la siguiente manera:
  

2. Se determina la proporción de unos:

3. Se calcula la chi2=X2

4.  Se calcula la p_value:

Código

	def frequency_block(list):
	print 'Test Block'
	n = len(list)
	M = 0.01*n
	N =int( n/M)
	blocks = []
	X2 = 0
	print type(blocks)
	i=0
	while(len(blocks) != N):
	blocks.append(list[i:(i+M)])
	i = i + M
	sumas = []
	for i in range(len(blocks)):
	sumas.append(0)
	for j in range(len(blocks[i])):
	sumas[i] = sumas[i] + blocks[i][j]/float(M)
	for i in range(N):
	X2 = X2 + math.pow((sumas[i] - .5), 2)
	X2 = X2 * 4*M
	df = M - 1
	p_value = chi2.cdf(X2, df)
	if p_value < 0.01:
	print "Frequency Test with Blocks: NOT PASSED"
	else:
	print "Frequency Test with Blocks: PASSED"

view raw bloques.py hosted with ❤ by GitHub

Captura de pantalla

Prueba de Póker

Lo que hace la prueba de póker es dividir la clave en numeros de 4 bist, por ejemplo si yo tengo esta:

0101000001100011

se divide de la siguiente manera :
0101 0000 0110 0011

entonces como se divide en 4 hay 16 posibles resulados que pueden salir y esos 16 resultados son contados las veces que estan o el número de frecuencias de cada uno.

La formula que se realiza es la siuiente:

en donde:
m = es el tamaño de la división de la secuencia en este caso 4
n = lóngitud o tamaño de la secuencia binaria
k = es la división de m entre n

Pasos:

1. Se divide la serie de número binarios en secciones de 4 numeros (0000).
2. Se buscan las frecuencias de los 16 diferentes numeros que se pueden encontrar
3. La frecuencia se eleva al cuadrado
4. Se realiza lo que es la ecuación anterior:

         x2=(16/k)(frecuencias al cuadrado)-k

La prueba se pasa cuando 1.03 < x < 57.4

	def poker(arch):
	n=len(arch) # Tam de la cadena binaria
	m=4 #longitud de los bloques
	numeros=list()#lista de separaciones de numeros de 4
	frecuencia=list() #lista para guardar las frecuencias
	y = n/m #cantidad de grupo de 4
	for i in range(y): # recorre la cantidad de grupos de 4
	numeros.append(arch[4*i:4+(4*i)]) #los agrega a la lista numeros
	for i in range(16): #realiza la lista de los 16 posibles numeros
	z=bin(i)[2:].zfill(4)
	frecuencia.append((numeros.count(z))**2) #cuenta las frecuencias de los numeros
	print frecuencia
	x = 0
	a= 16.0/y
	x = (a)*(sum(frecuencia)-y) #realiza la operacion
	print 'x---->', x
	if 1.03 < x < 57.4:
	print 'Poker Test: PASSED'
	else:
	print 'Poker Test: NOT PASSED'

view raw poker.py hosted with ❤ by GitHub

Captura de pantalla

Con otra cantidad de claves:

Monobit

Frecuencia de Bloques

Poker test

La clave pasa las pruebas eso quiere decir que es segura.

Referencias:

Link1
Link2
LInk3

One time Pad

One-time pad (OTP), also called Vernam-cipher or the perfect cipher, is a crypto algorithm where plaintext is combined with a random key. It is the only known method to perform mathematically unbreakable encryption. Used by Special Operations teams and resistance groups in WW2, popular with intelligence agencies and their spies during the Cold War and beyond, protecting diplomatic and military communications around the world for many decades, the one-time pad gained a reputation as a simple yet solid encryption system with an absolute security which is unmatched by today's modern crypto algorithms. Whatever technological progress may come in the future, one-time pad encryption is, and will remain, the only system to provide real long-term message security.

We can only talk about one-time pad if some important rules are followed. If these rules are applied correctly, the one-time pad can be proven unbreakable (see Claude Shannon's "Communication Theory of Secrecy Systems"). Even infinite computational power and infinite time cannot break one-time pad encryption, simply because it is mathematically impossible. However, if only one of these rules is disregarded, the cipher is no longer unbreakable.

• The key is at least as long as the message or data that must be encrypted.
• The key is truly random (not generated by a simple computer function or such)
• Key and plaintext are calculated modulo 10 (digits), modulo 26 (letters) or modulo 2 (binary)
• Each key is used only once, and both sender and receiver must destroy their key after use.
• There should only be two copies of the key: one for the sender and one for the receiver (some exceptions exist for multiple receivers.

One-Time-Pad-(xor)

Code:

	import random
	import shutil
	import os
	def generar_claves():
	k=''
	for m in range(4):
	s = binary(random.randint(0,255))
	k += s
	return k
	def binary(i):
	b = bin(i)[2:].zfill(8)
	return b
	def xor(m,s):
	x = ''
	for i in range(len(m)):
	if (m[i] != s[i]):
	x+="1"
	else:
	x+="0"
	return x
	def reader(msj):
	msj = open(msj, 'r')
	text = msj.read()[:-1]
	msj.close()
	return text
	def encrypt(msj, i):
	chipertext = ''
	for m in range(len(i)/8):
	chipertext +=xor(binary(ord(msj[m])),i[8*m:8+(8*m)])
	return chipertext
	def decrypt(chipertext,i):
	x = ''
	for m in range(len(chipertext)/8):
	x+=chr(int((xor(chipertext[8*m:8+(8 *m)],i[8*m:8+(8 *m)])),2))
	return x
	def tam_claves(claves):
	i = 0
	key = open('key.txt', 'w+r')
	while i<=(claves-1):
	k = generar_claves()
	key.write(k + '\n')
	i +=1
	key.close()
	return key
	def direcciones():
	src = 'key.txt'
	dir1 = 'A.txt'
	dir2 = 'B.txt'
	shutil.copy(src,dir1)
	shutil.copy(src,dir2)
	os.remove('key.txt')
	def bob(msj):
	chipertext = ''
	k = open('B.txt', 'r+')
	for i in k.readlines():
	i = i[:-1]
	chipertext = encrypt(msj,i)
	print 'Clave usada por Bob: ', i
	print 'Mensaje encriptado pro Bob: ', chipertext
	print 'Envia a Ana el texto encriptado'
	cambiar_key()
	print '\n'
	k.close()
	msj = Ana(chipertext)
	def cambiar_key():
	data = ''.join(open('B.txt', 'r+').readlines()[1:])
	open('B.txt', 'w+').write(data)
	def Ana(chipertext):
	print 'Ana recibe el mensaje encriptado'
	k = open('A.txt', 'r+')
	for i in k.readlines():
	i = i[:-1]
	print 'Ana comienza a desencriptar'
	msj_claro = decrypt(chipertext,i)
	print 'Clave usada por Ana: ', i
	print 'Mensaje decriptado: ', msj_claro
	print 'Enviando a Bob mensaje decriptado'
	data = ''.join(open('A.txt', 'r+').readlines()[1:])
	open('A.txt', 'w+').write(data)
	print '\n'
	k.close()
	return msj_claro
	def main():
	claves = int(raw_input('Cantidad de Claves: '))
	keys = tam_claves(claves)
	direcciones()
	print 'Se crearon las copia de las claves a los dos usuarios'
	msj = reader('texto_claro.txt')
	print 'El mensaje a encriptar y decriptar es:'+str(msj)
	bob(msj)
	main()

view raw otp_xor.py hosted with ❤ by GitHub

To start the program asks the number of keys that we will generate randomly, in my case is 2.

The Pograma generates two keys and saves them in a file and copy this file, when you do the copy deletes the original key.

Copies were created by users, print the message we send to encrypt.
Bob sends the encrypted message to Ana.

eliminates the key used 

 Ana receives and decrypts the message, the key used is the same.

Repeat the above using all the keys, and ends when all keys are deleted.

Image where the program ends

empty files

Funciones trigonométricas 

Las funciones trigonométricas se definen con el fin de extender el tema abarcado por las razones trigonométricas a todos los números reales y complejos.

Toman un gran papel en lo que es:

• La física
• La Astronomía
• Cartografía, etc...

Existen 6 funciones trigonométricas básicas las cuales son las siguientes:

A continuación se presentaran las equivalencias de cada una de las funciones trigonométricas.

Equivalencias de la función seno

Equivalencias de la función coseno

Equivalencias de la función tangente

Equivalencias de la función cotangente

Equivalencias de la función secante

Equivalencias de la función cosecante

Funciones graficadas con gnuplot

seno:

Para graficar con Gnuplot:

plot[-10:10]sin(x)

view raw gistfile1.txt hosted with ❤ by GitHub

Como vemos arriba en el rango de [-10:10, pude ser modificado para poder ver la función en un rango mayor.

Gráfica que nos arroja:

coseno

plot[-10:10]cos(x)

view raw 2 hosted with ❤ by GitHub

tangente

plot[-10:10]tan(x)

view raw 3 hosted with ❤ by GitHub

cotangente

plot[-10:10]1/tan(x)

view raw gistfile1.txt hosted with ❤ by GitHub

cosecante

plot[-10:10]1/cos(x)

view raw 5 hosted with ❤ by GitHub

 secantes

plot[-10:10]1/sen(x)

view raw 4 hosted with ❤ by GitHub

Holii

Hi

HOla