Initial commit

InjectionLexTest.py

@@ -0,0 +1,52 @@
+from SQLInjection import *
+
+if __name__ == '__main__':
+
+	sqlI = SQLInjection()
+
+	# Test 1
+	sample = """select cat from dog where casa=1 ;"""
+	u_input =  """select cat from dog where casa=2 ;"""
+
+	print "Test 1"
+	print "Sample:  ", sample
+	print "User In: ", u_input
+	print "Is Valid?: ", sqlI.validateLex(sample, u_input)
+	print
+
+	# Test 2
+
+	u_input = """select cat from dog where casa=1 and cat="miau" ;"""
+	print "Test 1"
+	print "Sample:  ", sample
+	print "User In: ", u_input
+	print "Is Valid?: ", sqlI.validateLex(sample, u_input)
+	print
+
+	# Interactive Example with user input
+
+	print "Follow the instruction and then try to inject SQL."
+
+	while True:
+		try: 
+			s = raw_input("Input a number> ")
+		except EOFError:
+			break
+
+		u_input = """select cat from dog where casa=%s ;""" %s
+		print "User query: %s" % u_input
+
+		try:
+			print "Is Valid?: ", sqlI.validateLex(sample, u_input)
+			s_counter, u_counter = sqlI.getLastTokCounters()
+			print "Token NUMBER  sample: %s\t user:%s" % (s_counter["NUMBER"], u_counter["NUMBER"])
+			print "Token ID      sample: %s\t user:%s" % (s_counter["ID"], u_counter["ID"])
+			print "Token LITERAL sample: %s\t user:%s" % (s_counter["LITERAL"], u_counter["LITERAL"])
+			print "Token AND+OR  sample: %s\t user:%s" % (s_counter["AND"] + s_counter["OR"], u_counter["AND"] + u_counter["OR"])
+			print 
+		except:
+			print "False"
+
+
+
+

README.md

@@ -0,0 +1,315 @@
+[English](#markdown-header-regular-expressions-sql-injection) | [Español](#markdown-header-expresiones-regulares-inyeccion-de-sql)
+
+# Expresiones Regulares - Inyección de SQL
+##Objetivos
+
+1. Practicar la implementación de expresiones regulares para construir un analizador lexicografico de una versión simple de una pregunta de selección de SQL.
+ 
+## Pre-Modulo:
+
+### Bajar PLY
+Obten PLY desde: http://www.dabeaz.com/ply/
+
+###Instalar PLY
+
+Descomprime el archivo:
+
+```
+tar xzvf ply-X.X.tar.gz
+```
+
+Entra al directorio creado:
+
+```
+cd ply-X.X
+```
+
+Construye los modulos de PLY:
+
+```
+python setup.py build
+```
+
+Instala PLY en el sistema como administrador:
+```
+sudo python setup.py install
+```
+
+### Pre-Modulo
+
+Antes de trabajar en este módulo el estudiante debe
+
+1. Haber repasado la construcción de expresiones regulares.
+2. Haber repasado la implementación de expresiones regulares en python.
+3. Haber leido sobre el constructor de analizadores lexicográficos lex.
+
+## Prevenir Inyección de SQL usando un analizador lexicográfico
+
+La validación de entradas es escencial en el desarrollo de aplicaciones seguras ya que es la primera línea de defensa de todas las aplicaciones.  La gran mayoría de las vulnerabilidades en aplicaciones es debido a pobre validación de las entradas de las aplicaciones. Ejemplo de vulnerabilidades explotadas por pobre validación de entradas lo son:
+
+1. Desbordamiento del Búfer 
+2. Cross Site Scripting
+3. Inyección de SQL, XML u otros lenguajes
+4. Recorrido de directorios
+5. Acceso a archivos privados
+
+Los atacantes utilizan errores en la validación de entradas para acceder a información privilegiada, para acceder a los sistemas, o para causar negación de servicios.
+
+Utilizando un analizador lexicográfico se puede comparar las fichas generadas por una pregunta de SQL válida con el tipo de entradas esperadas versus las fichas generadas por preguntas de SQL con entradas de usuario y determinar por la diferencia en la cantidad de fichas generadas si la entrada del usuario es válida.
+
+Un ejemplo de una pregunta de SQL sencilla es:
+
+```
+select * from infoprivada where contrasena="valor aleatorio desconocido" ;
+```
+
+Esta pregunta de SQL revelaría la información "privada" de un campo de una tabla si se provee la contraseña correcta.  En la aplicación donde se utiliza esta pregunta la entrada del usuario consiste de insertar la contraseña.  Un posible ataque que revelaría la información privada de toda la tabla sería que usuario insertara como valor la cadena de caracteres `1" or 1=1` que generaría la pregunta: 
+
+```
+select * from infoprivada where contrasena="1" or 1=1;
+```
+
+En cuyo caso por la lógica de la pregunta la expresión del WHERE es siempre cierta, y por lo tanto revelaría toda la información de la tabla. Para aprender más sobre Inyección de SQL vaya a la referencia[1].
+
+Para propósito de este módulo, el analizador lexicográfico que se va a construir sirve para obtener las fichas de una versión simplificada de la pregunta de selección de SQL cuyas fichas son las que siguen:
+
+SELECT, FROM, WHERE, AND, OR, NUMBER, ID, LITERAL, LPAREN `(`, RPAREN `)`, EQ, NEQ, GT, LT, GTE, LTE, SEMI, COMMA, WILD `*`, COMMENT
+
+Por ejemplo:
+
+Para la pregunta de SQL `select * from table where field=%s`, donde %s sería la entrada del usuario; la posible entrada que requiere la aplicación donde se está utilizando puede ser un número insertado por el usuario. 
+
+Como la entrada esperada es un número, una pregunta que se conoce que va a ser válida es `select * from table where field=1`, la cual generaría las fichas:
+
+SELECT, WILD, FROM, ID, WHERE, ID, EQ, NUMBER
+
+Si un usuario entrara cualquier otro número lo cual es válido, también se generarían las fichas 
+
+SELECT, WILD, FROM, ID, WHERE, ID, EQ, NUMBER
+
+Pero si el usuario en ves de entrar un número ingresara la entrada `1 or 1=1` para que la pregunta siempre sea cierta `select * from table where field=1 or 1=1` las fichas que se generarían son:
+
+SELECT, WILD, FROM, ID, WHERE, ID, EQ, NUMBER, OR, NUMBER, EQ, NUMBER
+
+que como se puede observar son diferente a la cantidad de fichas generadas por una pregunta válida ya que hay 2 fichas NUMBER y una ficha EQ más que en el número de fichas en un query válido.
+
+Otro ejemplo de una entrada inválida sería poner algo diferente a un número como una cadena de caracteres como myfield `select * from table where field=myfield` donde las fichas generadas serían:
+
+SELECT, WILD, FROM, ID, WHERE, ID, EQ, ID
+
+que como se puede observar la cantidad de fichas es la misma pero las fichas difieren en la última ficha.
+
+**Descargo de responsabilidad** Esto es un módulo cuyo proposito es enseñar expresiones regulares y construcción de analizadores lexicográficos utilizando una aplicación de seguridad.
+
+## Instrucciones generales
+
+En este módulo utilizaremos la librería de python PLY para construir un analizador lexicográfico de preguntas de selección de SQL simples.  El estudiante construirá expresiones regulares para completar el analizador lexicográfico y luego seguirá instrucciones para aprender como el analisis lexicográfico sirve para prevenir inyecciones de SQL.
+
+El archivo que el estudiante modificará para llevar a cabo este módulo es:
+`SQLLexer.py`
+
+
+## Ejercicio 1: Expresiones regulares para completar el analizador lexicográfico.
+
+Edite el archivo `SQLLexer.py` para completar las expresiones regulares en la sección que dice  # REGULAR EXPRESSION RULES FOR TOKENS
+
+1. Para `number` la expresión regular es uno o mas digitos.
+2. Para `identifier` la expresión regular empieza con un caracter del alfabeto o un subrayar (_), seguido por zero o mas caracteres del alfabeto, digitos o subrayares.
+3. Para `literal` la expresión regular comienza con comillas dobles, seguido por cualquier número de artículos que:
+    1. no son comillas dobles o barras invertida (\\)
+    2. o son una barra invertida seguida por cualquier caracter
+
+    y termina con comillas dobles.
+
+4. Para `comment` la expresión regular comienza con dos guiones, seguido por cualquier numero de caracteres.
+
+## Ejercicio 2: Correr el analizador lexicografico para contestar preguntas
+
+Corra el analizador lexicografico:
+```
+python  InjectionLexTest.py
+```
+Van a salir desplegadas dos pruebas donde se comparan una pregunta válida de ejemplo y otra donde las entradas del WHERE es distinta.
+
+1. Note que para la prueba 1, el resultado es válido.  Anote por qué?
+2. Note que para la prueba 2, el resultado es inválido.  Anote por qué?
+3. Inserte como entrada un número entero cualquiera. Es válido?  Por qué?
+4. Inserte como entrada `1 or 1=1`.  Es válido? Por qué?
+5. Inserte como entrada `"ccom" or casa=4`.  Es válido? Por qué?
+
+## Ejercicio 3: Un analizador léxico para preguntas de SQL para insertar
+
+Modifica el analizador léxico de el archivo `SQLLexer.py` para también analizar el léxico de preguntas de SQL simples como las siguientes: 
+
+insert into table (col1, col2, col3) value (id, 3, "literal") ;
+insert into table (col1, col2, col3) values (id, 3,"literal"), (id, 4, "otherliteral") ;
+
+**Nota** Crea una copia de el archivo `SQLLexer.py` del Ejercicio 1 porque necesitaras entregarlo al instructor con otra copia del `SQLLexer.py` para este ejercicio. 
+
+## Entregas
+
+Entregue al instructor una copia del archivo `SQLLexer.py` del Ejercicio 1 y el Ejercicio 3, y las contestaciones a las preguntas del Ejercicio 2.
+
+## References:
+[1] https://en.wikipedia.org/wiki/SQL_injection
+
+--- 
+
+[English](#markdown-header-regular-expressions-sql-injection) | [Español](#markdown-header-expresiones-regulares-inyeccion-de-sql)
+
+# Regular Expressions - SQL Injection
+
+##Objectives
+
+1. Practice the implementation of regular expressions to construct a lexical analyzer of a simple version of a SQL select query.
+ 
+## Pre-Module:
+
+### Download PLY
+Get PLY from: http://www.dabeaz.com/ply/
+
+###Install PLY
+
+Uncompress the file:
+
+```
+tar xzvf ply-X.X.tar.gz
+```
+
+Enter the directory created:
+
+```
+cd ply-X.X
+```
+
+Construct the PLY modules:
+
+```
+python setup.py build
+```
+
+Install PLY in the system as an administrator:
+
+```
+sudo python setup.py install
+```
+
+### Pre-Module
+
+Before working in this module the student must
+
+1. Have reviewed the construction of regular expressions.
+2. Have reviewed the implementation of regular expressions in python.
+3. Have read about the constructor of lexical analyzers lex.
+
+## Prevention SQL injection using a lexical analyzer
+
+Input validation is esential in the development of secure applications because it is the first line of defense of every application.  The vast majority of vulnerabilities in applications is due to poor input validation of the applications.  Example of vulnerabilities explited by poor input validation are:
+
+1. Buffer overflows
+2. Cross Site Scripting
+3. SQL, XML or other languages injection
+4. Directory Traversal
+5. Access to private files
+
+The attackers use errors in input validation to gain access to priviledged information, to gain access to systems, or to cause denial of services.
+
+Using a lexical analyzer we can compare the tokens generated by a valid SQL query with expected inputs types versus the tokens generated by a SQL query with user input and determine if the user input is valid by the differences in the amount of tokens. 
+
+An example of a simple SQL query is:
+
+```
+select * from infoprivada where contrasena="valor aleatorio desconocido" ;
+```
+
+This SQL query would reveal "private" information of a field of the a table if the right password is provided.  In the aplication where this query would be used the user input would consist of inserting the password.  A possible atack that would reveal the private information of all the table would be that the user inserts as a value the string `1" or 1=1` that would generate the query:
+
+```
+select * from infoprivada where contrasena="1" or 1=1;
+```
+
+In which case because of the logic of the query WHERE expression is always true, and therefore it would reveal all the information in the table.  To learn more about SQL injection go to reference [1].
+
+For the purpose of this module, the lexical analyzer that will be constructed will serve to obtain the tokens of a simplified version of the select SQL query which tokens are the following:
+
+SELECT, FROM, WHERE, AND, OR, NUMBER, ID, LITERAL, LPAREN `(`, RPAREN `)`, EQ, NEQ, GT, LT, GTE, LTE, SEMI, COMMA, WILD `*`, COMMENT
+
+For example:
+
+For the SQL query `select * from table where field=%s`, where %s would be the user input; the possible input requiered by the application where the query is being used could be a number inserted by the user.
+
+Because the expected input is a number, a query known to be valid is `select * from table where field=1`, which would generate the tokens:
+
+SELECT, WILD, FROM, ID, WHERE, ID, EQ, NUMBER
+
+If the user enters any other number, which is valid, also the following tokens would be generated:
+
+SELECT, WILD, FROM, ID, WHERE, ID, EQ, NUMBER
+
+But if the user instead of inserting a number inserts as input `1 or 1=1` to make the query always true `select * from table where field=1 or 1=1` the tokens that would be generated are:
+
+SELECT, WILD, FROM, ID, WHERE, ID, EQ, NUMBER, OR, NUMBER, EQ, NUMBER
+
+that as can be observed are different to the number of tokens generated by a valid query because there are two additional NUMBER tokens and one additional EQ token than in the number of tokens in the valid query.
+
+Another example of an invalid input would be to insert something different to a number such a string like myfield `select * from table where field=myfield` where the generated tokens would be:
+
+SELECT, WILD, FROM, ID, WHERE, ID, EQ, ID
+
+that as can be observed the number of tokens is the same but the tokens differ in the last token.
+
+**Disclaimer** This is a module which purpose is to teach regular expressions and to construct lexical analyzers using security as an application.
+
+## General Instructions
+
+In this module we will use the python library PLY to construct a lexical analyzer of simple selection SQL queries.  The student will construct regular expressions to complete the lexical analizer and then will follow instructions to learn how the lexical analyisis serves to prevent SQL injections.
+
+The file that the student will modify to accomplish this module is: `SQLLexer.py`
+
+
+## Exercise 1: Regular expression to complete the lexical analyzer
+
+Edit the file  `SQLLexer.py` to complete the regular expression in the secctions that says: # REGULAR EXPRESSION RULES FOR TOKENS
+
+1. For `number` the regular expression is one or more digits.
+2. For `identifier` the regular expression starts with an alphabet character or an underscore followed by zero or more alphabet characters, digits or underscores.
+3. For `literal` the regular expression starts with a double quote, followed by any number of items which are:
+    1. either not a double-quote or a backslash
+    2. or are a backslash followed by any single character
+    
+    and then finishes with a closing double-quote.
+
+4. For `comment` the regular expression start with two dashes, followed by any number of characters.
+
+## Exercise 2: Run the lexical analyzer and answer the questions
+
+Run the lexical analyzer:
+
+```
+python  InjectionLexTest.py
+```
+The comparison between two tests, one with a sample valid query and other with a different WHERE expressions input is displayed.
+
+1. Note that for test 1, the result is valid.  Why?
+2. Note that for test 2, the result is invalid. Why?
+3. Insert as input any integer number.  Is valid? Why?
+4. Insert as input `1 or 1=1`. Is valid? Why?
+5. Insert as input `"ccom" or casa=4`. Is valid? Why?
+``
+
+## Exercise 3: A lexical analyzer for insert queries
+
+Modify the lexical analyzer of file `SQLLexer.py` to also analyze the lexicon of simple insert SQL queries like the following:
+
+insert into table (col1, col2, col3) value (id, 3, "literal") ;
+insert into table (col1, col2, col3) values (id, 3,"literal"), (id, 4, "otherliteral") ;
+
+**Note** make a copy of the file `SQLLexer.py` from Exercise 1 because you need to give it to the instructor with another `SQLLexer.py` for this exercise. 
+
+## Deliverables
+
+Give the instructor a copy of the file `SQLLexer.py` from Exercise 1, and Exercise 3; and the answers to the questions from Exercise 2.
+
+## References:
+[1] https://en.wikipedia.org/wiki/SQL_injection
+

SQLInjection.py

@@ -0,0 +1,39 @@
+
+from SQLLexer import *
+
+class SQLInjection():
+
+	def __init__(self):
+			self.lexer = SQLLexer()
+			self.lexer.build()
+
+			self.u_tok_counter = None
+			self.s_tok_counter = None
+
+
+	def validateLex(self, sample_sql, user_sql):
+
+		self.s_tok_counter = self.lexer.getTokensHash()
+		self.u_tok_counter = self.lexer.getTokensHash()
+
+		for tok in self.lexer.tokenize(sample_sql):
+	 		self.s_tok_counter[tok.type] += 1
+
+	 	for tok in self.lexer.tokenize(user_sql):
+	 		self.u_tok_counter[tok.type] += 1
+
+	 	return self.s_tok_counter == self.u_tok_counter
+
+	def getLastTokCounters(self):
+		return self.s_tok_counter, self.u_tok_counter
+
+
+if __name__ == '__main__':
+
+	sqlI = SQLInjection()
+
+	# Test 1
+	print sqlI.validateLex("""select cat from dog where casa=1 ;""", """select cat from dog where casa=1 ;""")
+
+	# Test 2
+	print sqlI.validateLex("""select cat from dog where casa=1 ;""", """select cat from dog where casa=1 and cat="miau" ;""")

SQLLexer.py

@@ -0,0 +1,125 @@
+import ply.lex as lex
+from ply.lex import TOKEN
+
+class SQLLexer(object):
+	# List of token names.  
+
+	reserved = {
+	
+		'SELECT' : 'SELECT',
+		'select' : 'SELECT',
+		'FROM' : 'FROM', 
+		'from' : 'FROM', 
+		'WHERE' : 'WHERE',
+		'where' : 'WHERE',
+		'AND' : 'AND',
+		'and' : 'AND',
+		'or' : 'OR',
+		'OR' : 'OR'
+	}
+
+	tokens = [
+			'COMMENT',
+			'NUMBER', 'ID', 'LITERAL',
+			'LPAREN', 'RPAREN', 
+			'EQ', 'NEQ', 'GT', 'LT', 'LTE', 'GTE', 'SEMI', 'COMMA', 'WILD'] + list(set(list(reserved.values())))
+
+
+	# REGULAR EXPRESSION RULES FOR TOKENS
+
+	number = r''
+	identifier = r''
+	literal = r''
+	comment = r''
+
+	t_LPAREN = r'\('
+	t_RPAREN = r'\)'
+	t_LTE = r'<='
+	t_GTE = r'>='
+	t_LT = r'<'
+	t_GT = r'>'
+	t_EQ = r'='
+	t_NEQ = r'!='
+	t_SEMI = r';'
+	t_COMMA =r','
+	t_WILD = r'\*'
+
+	# Ignore space characters
+	t_ignore = ' \t\n'
+
+	# Actions nexts
+
+	# Only integer numbers for this example
+
+	@TOKEN(number)
+	def t_NUMBER(self, t):
+		t.value = int(t.value)
+		return t 
+
+	# Extract literals content
+
+	@TOKEN(literal)
+	def t_LITERAL(self, t):
+		if t.value == "\"\"":
+			t.value = ""
+		else:
+			t.value = t.value[1:len(t.value)-1]
+		return t
+
+	# Identifiers
+	@TOKEN(identifier)
+	def t_ID(self, t):
+		t.type = self.reserved.get(t.value, 'ID')
+		return t
+
+	# Ignore comments
+	@TOKEN(comment)
+	def t_COMMENT(self, t):
+		pass
+
+	def t_error(self, t):
+		print("Illegal character '%s'" % t.value[0])
+		raise
+		#t.lexer.skip(1)
+
+
+	#Build the lexer
+	def build(self, **kwargs):
+		self.lexer = lex.lex(module=self, **kwargs)
+
+
+	def input(self, data):
+		self.lexer.input(data)
+
+	def token(self):
+		return self.lexer.token()
+
+	def tokenize(self, data):
+		tokens = []
+		self.lexer.input(data)
+		while True:
+			tok = self.lexer.token()
+			if not tok:
+				break
+			tokens.append(tok)
+		return tokens
+
+	def getTokensHash(self):
+		return dict((k,0) for k in self.tokens)
+
+
+
+if __name__ == '__main__':
+	sqllex = SQLLexer()
+	sqllex.build()
+	tok_counter = sqllex.getTokensHash()
+	while True:
+		try: 
+			s = raw_input("sql> ")
+		except EOFError:
+			break
+		for tok in sqllex.tokenize(s):
+	 		print tok
+	 		tok_counter[tok.type] += 1
+
+	 	print tok_counter