How to pull off a successful NoSQL Injection attack

From NoSQL Injection to Serverside Javascript Injection

NoSQL (not only SQL) has disrupted the usage of traditional data stores. It has introduced a new concept of data storage which is non-relational unlike the previous storage mechanisms and thus, provides looser restrictions in consistency. It has a document store, key-value store, and graph. Due to the new requirements of modern-day applications, there has been wide adoption of NoSQL databases which could conveniently facilitate the distribution of data across numerous servers. Nosql databases provide an avenue for wide scalability and they require a single database node to execute all operations of the same transaction

NoSQL models offer a new data model and query formats making the old SQL injection attacks irrelevant. Yet, they give attackers new ways to insert malicious code.

Let’s understand the NoSQL data models in MongoDB:

Image for post

Image for post

The following diagram illustrates a query that selects and orders the matching documents using an index:

Image for post

Read operations retrievesdocuments from acollection i.e. queries a collection for documents. This is how you can read the documents from a collection in MongoDB:

Image for post

db.items.find(queryObject)

db — current database object

Items — collection names ‘items’ in the current database

find — method to execute on the collection

queryObject — an object used to select data

queryObject = {amount:0}; //items with fixed value ‘amount’ is 0

Before we go any further, let’s quickly analyze the attack mechanism in traditional SQL databases.

#security #vulerability #programming #web

What is GEEK

Buddha Community

How to pull off a successful NoSQL Injection attack

SharPyShell: Tiny & Obfuscated ASP.NET Webshell for C# Web Application

SharPyShell

SharPyShell is a tiny and obfuscated ASP.NET webshell that executes commands received by an encrypted channel compiling them in memory at runtime.

SharPyShell supports only C# web applications that runs on .NET Framework >= 2.0
VB is not supported atm.

Usage

python SharPyShell.py generate -p somepassword
python SharPyShell.py interact -u http://target.url/sharpyshell.aspx -p somepassword

Requirements

Python version >= 2.7

and

pip install -r requirements.txt

Description

SharPyShell is a post-exploitation framework written in Python that are capable of:

  • Generate obfuscated webshell (generate);
  • Simulate a windows terminal as an interaction for the webshell (interact).

The main aim of this framework is providing the penetration tester a series of tools to ease the post exploitation phase once an exploitation has been succesfull against an IIS webserver. 

This tool is not intended as a replacement of the frameworks for C2 Server (i.e. Meterpreter, Empire, ecc..) but this should be used when you land to a fully restricted server where inbound and outbound connections are very limited. 
In this framework you will have all the tools needed to privesc, netdiscovery and lateral movement as you are typing behind the cmd of the target server. 

Moreover this framework aim to be stealthy as much as possible implementing in memory execution for c# code and powershell modules. 

The obfuscation implemented in SharPyShell aim to evade both file signatures and network signatures ids.
For the network signatures evasion, a fully encrypted channel has been developed for sending commands and receiving outputs.
The evasion for file signatures has been achieved using Reflection on a precompiled dll in charge of runtime compiling c# code.
 

Technical Diagram

Generated with asciiflow.com

+-------------------------------------------+                      +--------------------------------------------+
| SharPyShell Client (Local)                |                      | Target Server (Remote)                     |
+-------------------------------------------+   +--------------+   +--------------------------------------------+
|                                           |   |  Encrypted   |   |                                            |
|   +--------+-----------------^-----------<---->     HTTP     <---->-----------+-----------------^--------+    |
|            |                 |            |   |   Channel    |   |            |                 |             |
|            |4-Receive        |1-Send      |   +--------------+   |            |2-Receive        |3-Send       |
|            |                 |            |                      |            |                 |             |
|   +--------v-----------------+--------+   |                      |   +--------v-----------------+--------+    |
|   |              Module               |   |                      |   |           Webshell URL            |    |
|   +--------+-----------------^--------+   |                      |   +--------+-----------------^--------+    |
|   |        |Parse            |Generate|   |                      |   |        |Parse            |Generate|    |
|   | +------v------+   +------+------+ |   |                      |   | +------v------+   +------+------+ |    |
|   | |Base64 Resp  |   |Base64 Req   | |   |                      |   | |Base64 Req   |   |Base64 Resp  | |    |
|   | +------+------+   +------^------+ |   |                      |   | +------+------+   +------^------+ |    |
|   |        |Decode           |Encode  |   |                      |   |        |Decode           |Encode  |    |
|   | +------v------+   +------+------+ |   |                      |   | +------v------+   +------+------+ |    |
|   | |Xor/Aes Data |   |Xor/Aes Data | |   |                      |   | |Xor/Aes Data |   |Xor/Aes Data | |    |
|   | +------+------+   +------^------+ |   |                      |   | +------+------+   +------^------+ |    |
|   |        |Decrypt          |Encrypt |   |                      |   |        |Decrypt          |Encrypt |    |
|   | +------v------+   +------+------+ |   |                      |   | +------v------+   +------+------+ |    |
|   | |Response     |   |C# Code      | |   |                      |   | |C# Code      |   |Output       | |    |
|   | +------+------+   +------+------+ |   |                      |   | +------+------+   +------+------+ |    |
|   |        |                 ^        |   |                      |   |        |                 ^        |    |
|   |        v                 |        |   |                      |   |        v                 |        |    |
|   |        +--------+--------+        |   |                      |   |        +--------+--------+        |    |
|   |                 |                 |   |                      |   |                 |                 |    |
|   +---------------- ^ ----------------+   |                      |   +---------------- ^ ----------------+    |
|                     |                     |                      |                     |                      |
|                     |Run&Parse            |                      |                     |Compile&Run           |
|                     |                     |                      |                     |                      |
|             +------ v ------+             |                      |             +------ v ------+              |
|             |Terminal       |             |                      |             |csc.exe        |              |
|             +---------------+             |                      |             +---------------+              |
|             |Modules:       |             |                      |             |System.dll     |              |
|             |#exec_cmd      |             |                      |             |Compile in Mem |              |
|             |#exec_ps       |             |                      |             |No exe output  |              |
|             |#runas         |             |                      |             |               |              |
|             |.....          |             |                      |             |               |              |
|             |               |             |                      |             |               |              |
|             +---------------+             |                      |             +---------------+              |
|                                           |                      |                                            |
+-------------------------------------------+                      +--------------------------------------------+

Modules

 #download               Download a file from the server                                            
 #exec_cmd               Run a cmd.exe /c command on the server                                     
 #exec_ps                Run a powershell.exe -nop -noni -enc 'base64command' on the server         
 #inject_dll_reflective  Inject a reflective DLL in a new (or existing) process                     
 #inject_dll_srdi        Inject a generic DLL in a new (or existing) process                        
 #inject_shellcode       Inject shellcode in a new (or existing) process                            
 #invoke_ps_module       Run a ps1 script on the target server                                      
 #invoke_ps_module_as    Run a ps1 script on the target server as a specific user                   
 #lateral_psexec         Run psexec binary to move laterally                                        
 #lateral_wmi            Run builtin WMI command to move laterally                                  
 #mimikatz               Run an offline version of mimikatz directly in memory                      
 #net_portscan           Run a port scan using regular sockets, based (pretty) loosely on nmap      
 #privesc_juicy_potato   Launch InMem Juicy Potato attack trying to impersonate NT AUTHORITY\SYSTEM 
 #privesc_powerup        Run Powerup module to assess all misconfiguration for privesc              
 #runas                  Run a cmd.exe /c command spawning a new process as a specific user         
 #runas_ps               Run a powershell.exe -enc spawning a new process as a specific user        
 #upload                 Upload a file to the server 

Windows version tested

Windows Server >= 2008 Standard x64

Download Details:
Author: antonioCoco
Source Code: https://github.com/antonioCoco/SharPyShell
License: GPL-3.0 License

#csharp  #dotnet  #aspdotnet 

Juanita  Apio

Juanita Apio

1623180540

SQL vs NoSQL and SQL to NoSQL Migration

Overview

Given the choice of a Relational Database (RDBMS) vs a NoSQL database, it has become more important to select the right type of database for storing data. Not all the requirements fit in a NoSQL database or an RDBMS. RDBMSs are mainly related to managing, storing, and manipulating structured data where the data format, columns, data type, attributes, and schema are fixed, and the relationship between entities needs to be consistently maintained.

SQL is a common query language used when dealing with an RDBMS. Using an RDBMS is a choice for storing transactional data or records where the ACID (Atomicity, Consistency, Isolation, Durability) proprieties of transactions must be provided by an underlying database. An RDBMS is also a choice where the security and accessibility of data are of utmost importance. Typical use cases are financial records, financial transactions, OLTP, ERP, CRM systems, e-commerce applications, etc.

NoSQL (sometimes referred to as Not only SQL, non-SQL or non-relational) is a database that is suitable for managing data that is non-relational, i.e. not structured in tabular format or have fixed data type formats and variables that do not possess tabular relationships. There are various types of NoSQL databases that exist, like key-value, document-based, column-based, and graph-based. When it comes to scalability and performance of unstructured data, NoSQL is the obvious choice.

In a recent development, a few graph databases provide the options to store transactions adhering to ACID properties, but they are still in the early phases of adoption. Typical uses cases of NoSQL include data that is largely unstructured and needs flexibility in data models like content management, personalization, web search engines, storing large users profiles from heterogeneous sources, data streams, documents, digital communication (Storing messages, chats), big data, analytics, machine learning, and storing IoT data.

It becomes imperative to choose the right type of database, and, if required, migrate the exiting RDBMS database to NoSQL to meet the new dynamics of business requirements, scalability, and performance aspects. The below section will help in deciding the right database for your requirement.

1. Database Decision Tree

2. Migration From RDBMS Data Sources to NoSQL DBs

If there are existing RDBMS databases that are storing content, documents, files, or have unstructured data, then there are significant advantages in moving such databases to NoSQL databases. Benefits include cost benefits, performance, scalability, future proof for changes, reducing conversion jobs, and extensive supportability for analytics.

2.1 Migration Tools From Traditional RDBMS DB to AWS DynamoDB

AWS Database Migration Service (AWS DMS) can migrate data from most widely-used commercial RDBMSs and open-source databases to similar databases (homogeneous) or different database platforms (heterogeneous) including transforming RDBMS to DynamoDB or Cassandra to DynamoDB or MongoDB to DynamoDB databases.

2.2 Migration Tools for RDBMS DB to Azure Cosmos DB

The Azure Cosmos DB emulator and the Azure Cosmos DB Data Migration tool can be used to migrate from an MSSQL database to Cosmos DB. This tool can also help to migrate if the source data is in CSV or JSON object formats.

Azure Database Migration Service (DMS), Cosmos DB, and the API for MongoDB can be used to migrate MongoDB to CosmosDB.

2.3 Migration From SQL to Google DataStore

Google has NoSQL services, Cloud Datastore, and Bigtable. Cloud Datastore is now being enhanced to recently released service called Firestore.

There are not many tools and documentation support from Google on migration to Firestore or Bigtable from RDBMS databases or different NoSQL platforms. Cloud SQL, a managed RDBMS from Google, has built-in features to migrate some of traditional RDBMS to CloudSQL. Cloud Spanner is another managed RDBMS. Migrations involve mainly manual processes.

#nosql #aws #azure #sql #nosql

Cómo Extraer Datos De Twitter Usando Tweepy Y Snscrape

Si es un entusiasta de los datos, probablemente estará de acuerdo en que una de las fuentes más ricas de datos del mundo real son las redes sociales. Sitios como Twitter están llenos de datos.

Puede usar los datos que puede obtener de las redes sociales de varias maneras, como el análisis de sentimientos (análisis de los pensamientos de las personas) sobre un tema o campo de interés específico.

Hay varias formas de raspar (o recopilar) datos de Twitter. Y en este artículo, veremos dos de esas formas: usando Tweepy y Snscrape.

Aprenderemos un método para recopilar conversaciones públicas de personas sobre un tema de tendencia específico, así como tweets de un usuario en particular.

Ahora, sin más preámbulos, comencemos.

Tweepy vs Snscrape – Introducción a nuestras herramientas de raspado

Ahora, antes de entrar en la implementación de cada plataforma, intentemos comprender las diferencias y los límites de cada plataforma.

llorona

Tweepy es una biblioteca de Python para integrarse con la API de Twitter. Debido a que Tweepy está conectado con la API de Twitter, puede realizar consultas complejas además de raspar tweets. Le permite aprovechar todas las capacidades de la API de Twitter.

Pero hay algunos inconvenientes, como el hecho de que su API estándar solo le permite recopilar tweets durante un máximo de una semana (es decir, Tweepy no permite la recuperación de tweets más allá de una ventana de una semana, por lo que no se permite la recuperación de datos históricos).

Además, hay límites en la cantidad de tweets que puede recuperar de la cuenta de un usuario. Puedes leer más sobre las funcionalidades de Tweepy aquí .

Snscrape

Snscrape es otro enfoque para extraer información de Twitter que no requiere el uso de una API. Snscrape le permite recopilar información básica, como el perfil de un usuario, el contenido del tweet, la fuente, etc.

Snscrape no se limita a Twitter, sino que también puede extraer contenido de otras redes sociales destacadas como Facebook, Instagram y otras.

Sus ventajas son que no hay límites para la cantidad de tweets que puede recuperar o la ventana de tweets (es decir, el rango de fechas de los tweets). Entonces Snscrape le permite recuperar datos antiguos.

Pero la única desventaja es que carece de todas las demás funcionalidades de Tweepy; aún así, si solo desea raspar tweets, Snscrape sería suficiente.

Ahora que hemos aclarado la distinción entre los dos métodos, repasemos su implementación uno por uno.

Cómo usar Tweepy para raspar tweets

Antes de comenzar a usar Tweepy, primero debemos asegurarnos de que nuestras credenciales de Twitter estén listas. Con eso, podemos conectar Tweepy a nuestra clave API y comenzar a raspar.

Si no tiene credenciales de Twitter, puede registrarse para obtener una cuenta de desarrollador de Twitter yendo aquí . Se le harán algunas preguntas básicas sobre cómo pretende utilizar la API de Twitter. Después de eso, puede comenzar la implementación.

El primer paso es instalar la biblioteca Tweepy en su máquina local, lo que puede hacer escribiendo:

pip install git+https://github.com/tweepy/tweepy.git

Cómo extraer tweets de un usuario en Twitter

Ahora que hemos instalado la biblioteca Tweepy, raspamos 100 tweets de un usuario llamado johnen Twitter. Veremos la implementación del código completo que nos permitirá hacer esto y lo discutiremos en detalle para que podamos comprender lo que está sucediendo:

import tweepy

consumer_key = "XXXX" #Your API/Consumer key 
consumer_secret = "XXXX" #Your API/Consumer Secret Key
access_token = "XXXX"    #Your Access token key
access_token_secret = "XXXX" #Your Access token Secret key

#Pass in our twitter API authentication key
auth = tweepy.OAuth1UserHandler(
    consumer_key, consumer_secret,
    access_token, access_token_secret
)

#Instantiate the tweepy API
api = tweepy.API(auth, wait_on_rate_limit=True)


username = "john"
no_of_tweets =100


try:
    #The number of tweets we want to retrieved from the user
    tweets = api.user_timeline(screen_name=username, count=no_of_tweets)
    
    #Pulling Some attributes from the tweet
    attributes_container = [[tweet.created_at, tweet.favorite_count,tweet.source,  tweet.text] for tweet in tweets]

    #Creation of column list to rename the columns in the dataframe
    columns = ["Date Created", "Number of Likes", "Source of Tweet", "Tweet"]
    
    #Creation of Dataframe
    tweets_df = pd.DataFrame(attributes_container, columns=columns)
except BaseException as e:
    print('Status Failed On,',str(e))
    time.sleep(3)

Ahora repasemos cada parte del código en el bloque anterior.

import tweepy

consumer_key = "XXXX" #Your API/Consumer key 
consumer_secret = "XXXX" #Your API/Consumer Secret Key
access_token = "XXXX"    #Your Access token key
access_token_secret = "XXXX" #Your Access token Secret key

#Pass in our twitter API authentication key
auth = tweepy.OAuth1UserHandler(
    consumer_key, consumer_secret,
    access_token, access_token_secret
)

#Instantiate the tweepy API
api = tweepy.API(auth, wait_on_rate_limit=True)

En el código anterior, hemos importado la biblioteca Tweepy a nuestro código, luego hemos creado algunas variables donde almacenamos nuestras credenciales de Twitter (el controlador de autenticación de Tweepy requiere cuatro de nuestras credenciales de Twitter). Entonces pasamos esas variables al controlador de autenticación Tweepy y las guardamos en otra variable.

Luego, la última declaración de llamada es donde instanciamos la API de Tweepy y pasamos los parámetros requeridos.

username = "john"
no_of_tweets =100


try:
    #The number of tweets we want to retrieved from the user
    tweets = api.user_timeline(screen_name=username, count=no_of_tweets)
    
    #Pulling Some attributes from the tweet
    attributes_container = [[tweet.created_at, tweet.favorite_count,tweet.source,  tweet.text] for tweet in tweets]

    #Creation of column list to rename the columns in the dataframe
    columns = ["Date Created", "Number of Likes", "Source of Tweet", "Tweet"]
    
    #Creation of Dataframe
    tweets_df = pd.DataFrame(attributes_container, columns=columns)
except BaseException as e:
    print('Status Failed On,',str(e))

En el código anterior, creamos el nombre del usuario (el @nombre en Twitter) del que queremos recuperar los tweets y también la cantidad de tweets. Luego creamos un controlador de excepciones para ayudarnos a detectar errores de una manera más efectiva.

Después de eso, api.user_timeline()devuelve una colección de los tweets más recientes publicados por el usuario que elegimos en el screen_nameparámetro y la cantidad de tweets que desea recuperar.

En la siguiente línea de código, pasamos algunos atributos que queremos recuperar de cada tweet y los guardamos en una lista. Para ver más atributos que puede recuperar de un tweet, lea esto .

En el último fragmento de código, creamos un marco de datos y pasamos la lista que creamos junto con los nombres de la columna que creamos.

Tenga en cuenta que los nombres de las columnas deben estar en la secuencia de cómo los pasó al contenedor de atributos (es decir, cómo pasó esos atributos en una lista cuando estaba recuperando los atributos del tweet).

Si seguiste correctamente los pasos que describí, deberías tener algo como esto:

imagen-17

Imagen por autor

Ahora que hemos terminado, repasemos un ejemplo más antes de pasar a la implementación de Snscrape.

Cómo extraer tweets de una búsqueda de texto

En este método, recuperaremos un tweet basado en una búsqueda. Puedes hacerlo así:

import tweepy

consumer_key = "XXXX" #Your API/Consumer key 
consumer_secret = "XXXX" #Your API/Consumer Secret Key
access_token = "XXXX"    #Your Access token key
access_token_secret = "XXXX" #Your Access token Secret key

#Pass in our twitter API authentication key
auth = tweepy.OAuth1UserHandler(
    consumer_key, consumer_secret,
    access_token, access_token_secret
)

#Instantiate the tweepy API
api = tweepy.API(auth, wait_on_rate_limit=True)


search_query = "sex for grades"
no_of_tweets =150


try:
    #The number of tweets we want to retrieved from the search
    tweets = api.search_tweets(q=search_query, count=no_of_tweets)
    
    #Pulling Some attributes from the tweet
    attributes_container = [[tweet.user.name, tweet.created_at, tweet.favorite_count, tweet.source,  tweet.text] for tweet in tweets]

    #Creation of column list to rename the columns in the dataframe
    columns = ["User", "Date Created", "Number of Likes", "Source of Tweet", "Tweet"]
    
    #Creation of Dataframe
    tweets_df = pd.DataFrame(attributes_container, columns=columns)
except BaseException as e:
    print('Status Failed On,',str(e))

El código anterior es similar al código anterior, excepto que cambiamos el método API de api.user_timeline()a api.search_tweets(). También hemos agregado tweet.user.namea la lista de contenedores de atributos.

En el código anterior, puede ver que pasamos dos atributos. Esto se debe a que si solo pasamos tweet.user, solo devolvería un objeto de usuario de diccionario. Entonces, también debemos pasar otro atributo que queremos recuperar del objeto de usuario, que es name.

Puede ir aquí para ver una lista de atributos adicionales que puede recuperar de un objeto de usuario. Ahora deberías ver algo como esto una vez que lo ejecutes:

imagen-18

Imagen por Autor.

Muy bien, eso casi concluye la implementación de Tweepy. Solo recuerda que hay un límite en la cantidad de tweets que puedes recuperar, y no puedes recuperar tweets de más de 7 días usando Tweepy.

Cómo usar Snscrape para raspar tweets

Como mencioné anteriormente, Snscrape no requiere credenciales de Twitter (clave API) para acceder a él. Tampoco hay límite para la cantidad de tweets que puede obtener.

Para este ejemplo, sin embargo, solo recuperaremos los mismos tweets que en el ejemplo anterior, pero usando Snscrape en su lugar.

Para usar Snscrape, primero debemos instalar su biblioteca en nuestra PC. Puedes hacerlo escribiendo:

pip3 install git+https://github.com/JustAnotherArchivist/snscrape.git

Cómo raspar tweets de un usuario con Snscrape

Snscrape incluye dos métodos para obtener tweets de Twitter: la interfaz de línea de comandos (CLI) y Python Wrapper. Solo tenga en cuenta que Python Wrapper actualmente no está documentado, pero aún podemos salir adelante con prueba y error.

En este ejemplo, usaremos Python Wrapper porque es más intuitivo que el método CLI. Pero si te quedas atascado con algún código, siempre puedes recurrir a la comunidad de GitHub para obtener ayuda. Los colaboradores estarán encantados de ayudarte.

Para recuperar tweets de un usuario en particular, podemos hacer lo siguiente:

import snscrape.modules.twitter as sntwitter
import pandas as pd

# Created a list to append all tweet attributes(data)
attributes_container = []

# Using TwitterSearchScraper to scrape data and append tweets to list
for i,tweet in enumerate(sntwitter.TwitterSearchScraper('from:john').get_items()):
    if i>100:
        break
    attributes_container.append([tweet.date, tweet.likeCount, tweet.sourceLabel, tweet.content])
    
# Creating a dataframe from the tweets list above 
tweets_df = pd.DataFrame(attributes_container, columns=["Date Created", "Number of Likes", "Source of Tweet", "Tweets"])

Repasemos algunos de los códigos que quizás no entiendas a primera vista:

for i,tweet in enumerate(sntwitter.TwitterSearchScraper('from:john').get_items()):
    if i>100:
        break
    attributes_container.append([tweet.date, tweet.likeCount, tweet.sourceLabel, tweet.content])
    
  
# Creating a dataframe from the tweets list above 
tweets_df = pd.DataFrame(attributes_container, columns=["Date Created", "Number of Likes", "Source of Tweet", "Tweets"])

En el código anterior, lo que sntwitter.TwitterSearchScaperhace es devolver un objeto de tweets del nombre del usuario que le pasamos (que es john).

Como mencioné anteriormente, Snscrape no tiene límites en la cantidad de tweets, por lo que devolverá la cantidad de tweets de ese usuario. Para ayudar con esto, necesitamos agregar la función de enumeración que iterará a través del objeto y agregará un contador para que podamos acceder a los 100 tweets más recientes del usuario.

Puede ver que la sintaxis de los atributos que obtenemos de cada tweet se parece a la de Tweepy. Esta es la lista de atributos que podemos obtener del tweet Snscrape que fue curado por Martin Beck.

Sns.Scrape

Crédito: Martin Beck

Se pueden agregar más atributos, ya que la biblioteca Snscrape aún está en desarrollo. Como por ejemplo en la imagen de arriba, sourceha sido reemplazado por sourceLabel. Si pasa solo sourcedevolverá un objeto.

Si ejecuta el código anterior, también debería ver algo como esto:

imagen-19

Imagen por autor

Ahora hagamos lo mismo para raspar por búsqueda.

Cómo extraer tweets de una búsqueda de texto con Snscrape

import snscrape.modules.twitter as sntwitter
import pandas as pd

# Creating list to append tweet data to
attributes_container = []

# Using TwitterSearchScraper to scrape data and append tweets to list
for i,tweet in enumerate(sntwitter.TwitterSearchScraper('sex for grades since:2021-07-05 until:2022-07-06').get_items()):
    if i>150:
        break
    attributes_container.append([tweet.user.username, tweet.date, tweet.likeCount, tweet.sourceLabel, tweet.content])
    
# Creating a dataframe to load the list
tweets_df = pd.DataFrame(attributes_container, columns=["User", "Date Created", "Number of Likes", "Source of Tweet", "Tweet"])

Nuevamente, puede acceder a una gran cantidad de datos históricos utilizando Snscrape (a diferencia de Tweepy, ya que su API estándar no puede exceder los 7 días. La API premium es de 30 días). Entonces podemos pasar la fecha a partir de la cual queremos comenzar la búsqueda y la fecha en la que queremos que finalice en el sntwitter.TwitterSearchScraper()método.

Lo que hemos hecho en el código anterior es básicamente lo que discutimos antes. Lo único a tener en cuenta es que hasta funciona de manera similar a la función de rango en Python (es decir, excluye el último entero). Entonces, si desea obtener tweets de hoy, debe incluir el día después de hoy en el parámetro "hasta".

imagen-21

Imagen de Autor.

¡Ahora también sabes cómo raspar tweets con Snscrape!

Cuándo usar cada enfoque

Ahora que hemos visto cómo funciona cada método, es posible que se pregunte cuándo usar cuál.

Bueno, no existe una regla universal sobre cuándo utilizar cada método. Todo se reduce a una preferencia de materia y su caso de uso.

Si desea adquirir un sinfín de tweets, debe usar Snscrape. Pero si desea utilizar funciones adicionales que Snscrape no puede proporcionar (como la geolocalización, por ejemplo), definitivamente debería utilizar Tweepy. Se integra directamente con la API de Twitter y proporciona una funcionalidad completa.

Aun así, Snscrape es el método más utilizado para el raspado básico.

Conclusión

En este artículo, aprendimos cómo extraer datos de Python usando Tweepy y Snscrape. Pero esto fue solo una breve descripción de cómo funciona cada enfoque. Puede obtener más información explorando la web para obtener información adicional.

He incluido algunos recursos útiles que puede usar si necesita información adicional. Gracias por leer.

 Fuente: https://www.freecodecamp.org/news/python-web-scraping-tutorial/

#python #web 

How to pull off a successful NoSQL Injection attack

From NoSQL Injection to Serverside Javascript Injection

NoSQL (not only SQL) has disrupted the usage of traditional data stores. It has introduced a new concept of data storage which is non-relational unlike the previous storage mechanisms and thus, provides looser restrictions in consistency. It has a document store, key-value store, and graph. Due to the new requirements of modern-day applications, there has been wide adoption of NoSQL databases which could conveniently facilitate the distribution of data across numerous servers. Nosql databases provide an avenue for wide scalability and they require a single database node to execute all operations of the same transaction

NoSQL models offer a new data model and query formats making the old SQL injection attacks irrelevant. Yet, they give attackers new ways to insert malicious code.

Let’s understand the NoSQL data models in MongoDB:

Image for post

Image for post

The following diagram illustrates a query that selects and orders the matching documents using an index:

Image for post

Read operations retrievesdocuments from acollection i.e. queries a collection for documents. This is how you can read the documents from a collection in MongoDB:

Image for post

db.items.find(queryObject)

db — current database object

Items — collection names ‘items’ in the current database

find — method to execute on the collection

queryObject — an object used to select data

queryObject = {amount:0}; //items with fixed value ‘amount’ is 0

Before we go any further, let’s quickly analyze the attack mechanism in traditional SQL databases.

#security #vulerability #programming #web

Como Extrair Dados Do Twitter Usando Tweepy E Snscrape

Se você é um entusiasta de dados, provavelmente concordará que uma das fontes mais ricas de dados do mundo real são as mídias sociais. Sites como o Twitter estão cheios de dados.

Você pode usar os dados obtidos nas mídias sociais de várias maneiras, como análise de sentimentos (analisando os pensamentos das pessoas) sobre um assunto ou campo de interesse específico.

Existem várias maneiras de extrair (ou coletar) dados do Twitter. E neste artigo, veremos duas dessas maneiras: usando o Tweepy e o Snscrape.

Aprenderemos um método para extrair conversas públicas de pessoas sobre um tópico de tendência específico, bem como tweets de um usuário específico.

Agora sem mais delongas, vamos começar.

Tweepy vs Snscrape – Introdução às nossas ferramentas de raspagem

Agora, antes de entrarmos na implementação de cada plataforma, vamos tentar entender as diferenças e os limites de cada plataforma.

Tweepy

Tweepy é uma biblioteca Python para integração com a API do Twitter. Como o Tweepy está conectado à API do Twitter, você pode realizar consultas complexas além de extrair tweets. Ele permite que você aproveite todos os recursos da API do Twitter.

Mas existem algumas desvantagens – como o fato de que sua API padrão só permite coletar tweets por até uma semana (ou seja, o Tweepy não permite a recuperação de tweets além de uma janela de semana, portanto, a recuperação de dados históricos não é permitida).

Além disso, há limites para quantos tweets você pode recuperar da conta de um usuário. Você pode ler mais sobre as funcionalidades do Tweepy aqui .

Snscrape

Snscrape é outra abordagem para extrair informações do Twitter que não requer o uso de uma API. O Snscrape permite extrair informações básicas, como o perfil de um usuário, conteúdo do tweet, fonte e assim por diante.

O Snscrape não se limita ao Twitter, mas também pode extrair conteúdo de outras redes sociais proeminentes, como Facebook, Instagram e outros.

Suas vantagens são que não há limites para o número de tweets que você pode recuperar ou a janela de tweets (ou seja, o intervalo de datas dos tweets). Então Snscrape permite que você recupere dados antigos.

Mas a única desvantagem é que ele não possui todas as outras funcionalidades do Tweepy – ainda assim, se você quiser apenas raspar tweets, o Snscrape seria suficiente.

Agora que esclarecemos a distinção entre os dois métodos, vamos analisar sua implementação um por um.

Como usar o Tweepy para raspar tweets

Antes de começarmos a usar o Tweepy, devemos primeiro ter certeza de que nossas credenciais do Twitter estão prontas. Com isso, podemos conectar o Tweepy à nossa chave de API e começar a raspar.

Se você não tiver credenciais do Twitter, poderá se registrar para uma conta de desenvolvedor do Twitter acessando aqui . Serão feitas algumas perguntas básicas sobre como você pretende usar a API do Twitter. Depois disso, você pode começar a implementação.

O primeiro passo é instalar a biblioteca Tweepy em sua máquina local, o que você pode fazer digitando:

pip install git+https://github.com/tweepy/tweepy.git

Como raspar tweets de um usuário no Twitter

Agora que instalamos a biblioteca Tweepy, vamos extrair 100 tweets de um usuário chamado johnno Twitter. Veremos a implementação completa do código que nos permitirá fazer isso e discutiremos em detalhes para que possamos entender o que está acontecendo:

import tweepy

consumer_key = "XXXX" #Your API/Consumer key 
consumer_secret = "XXXX" #Your API/Consumer Secret Key
access_token = "XXXX"    #Your Access token key
access_token_secret = "XXXX" #Your Access token Secret key

#Pass in our twitter API authentication key
auth = tweepy.OAuth1UserHandler(
    consumer_key, consumer_secret,
    access_token, access_token_secret
)

#Instantiate the tweepy API
api = tweepy.API(auth, wait_on_rate_limit=True)


username = "john"
no_of_tweets =100


try:
    #The number of tweets we want to retrieved from the user
    tweets = api.user_timeline(screen_name=username, count=no_of_tweets)
    
    #Pulling Some attributes from the tweet
    attributes_container = [[tweet.created_at, tweet.favorite_count,tweet.source,  tweet.text] for tweet in tweets]

    #Creation of column list to rename the columns in the dataframe
    columns = ["Date Created", "Number of Likes", "Source of Tweet", "Tweet"]
    
    #Creation of Dataframe
    tweets_df = pd.DataFrame(attributes_container, columns=columns)
except BaseException as e:
    print('Status Failed On,',str(e))
    time.sleep(3)

Agora vamos examinar cada parte do código no bloco acima.

import tweepy

consumer_key = "XXXX" #Your API/Consumer key 
consumer_secret = "XXXX" #Your API/Consumer Secret Key
access_token = "XXXX"    #Your Access token key
access_token_secret = "XXXX" #Your Access token Secret key

#Pass in our twitter API authentication key
auth = tweepy.OAuth1UserHandler(
    consumer_key, consumer_secret,
    access_token, access_token_secret
)

#Instantiate the tweepy API
api = tweepy.API(auth, wait_on_rate_limit=True)

No código acima, importamos a biblioteca Tweepy para nosso código e criamos algumas variáveis ​​nas quais armazenamos nossas credenciais do Twitter (o manipulador de autenticação do Tweepy requer quatro de nossas credenciais do Twitter). Então, passamos essas variáveis ​​para o manipulador de autenticação Tweepy e as salvamos em outra variável.

Em seguida, a última instrução de chamada é onde instanciamos a API do Tweepy e passamos os parâmetros require.

username = "john"
no_of_tweets =100


try:
    #The number of tweets we want to retrieved from the user
    tweets = api.user_timeline(screen_name=username, count=no_of_tweets)
    
    #Pulling Some attributes from the tweet
    attributes_container = [[tweet.created_at, tweet.favorite_count,tweet.source,  tweet.text] for tweet in tweets]

    #Creation of column list to rename the columns in the dataframe
    columns = ["Date Created", "Number of Likes", "Source of Tweet", "Tweet"]
    
    #Creation of Dataframe
    tweets_df = pd.DataFrame(attributes_container, columns=columns)
except BaseException as e:
    print('Status Failed On,',str(e))

No código acima, criamos o nome do usuário (o @name no Twitter) do qual queremos recuperar os tweets e também o número de tweets. Em seguida, criamos um manipulador de exceção para nos ajudar a detectar erros de maneira mais eficaz.

Depois disso, o api.user_timeline()retorna uma coleção dos tweets mais recentes postados pelo usuário que escolhemos no screen_nameparâmetro e o número de tweets que você deseja recuperar.

Na próxima linha de código, passamos alguns atributos que queremos recuperar de cada tweet e os salvamos em uma lista. Para ver mais atributos que você pode recuperar de um tweet, leia isto .

No último pedaço de código criamos um dataframe e passamos a lista que criamos junto com os nomes da coluna que criamos.

Observe que os nomes das colunas devem estar na sequência de como você os passou para o contêiner de atributos (ou seja, como você passou esses atributos em uma lista quando estava recuperando os atributos do tweet).

Se você seguiu corretamente os passos que descrevi, você deve ter algo assim:

imagem-17

Imagem do autor

Agora que terminamos, vamos ver mais um exemplo antes de passarmos para a implementação do Snscrape.

Como raspar tweets de uma pesquisa de texto

Neste método, estaremos recuperando um tweet com base em uma pesquisa. Você pode fazer assim:

import tweepy

consumer_key = "XXXX" #Your API/Consumer key 
consumer_secret = "XXXX" #Your API/Consumer Secret Key
access_token = "XXXX"    #Your Access token key
access_token_secret = "XXXX" #Your Access token Secret key

#Pass in our twitter API authentication key
auth = tweepy.OAuth1UserHandler(
    consumer_key, consumer_secret,
    access_token, access_token_secret
)

#Instantiate the tweepy API
api = tweepy.API(auth, wait_on_rate_limit=True)


search_query = "sex for grades"
no_of_tweets =150


try:
    #The number of tweets we want to retrieved from the search
    tweets = api.search_tweets(q=search_query, count=no_of_tweets)
    
    #Pulling Some attributes from the tweet
    attributes_container = [[tweet.user.name, tweet.created_at, tweet.favorite_count, tweet.source,  tweet.text] for tweet in tweets]

    #Creation of column list to rename the columns in the dataframe
    columns = ["User", "Date Created", "Number of Likes", "Source of Tweet", "Tweet"]
    
    #Creation of Dataframe
    tweets_df = pd.DataFrame(attributes_container, columns=columns)
except BaseException as e:
    print('Status Failed On,',str(e))

O código acima é semelhante ao código anterior, exceto que alteramos o método da API de api.user_timeline()para api.search_tweets(). Também adicionamos tweet.user.nameà lista de contêineres de atributos.

No código acima, você pode ver que passamos dois atributos. Isso ocorre porque se passarmos apenas tweet.user, ele retornaria apenas um objeto de usuário de dicionário. Portanto, também devemos passar outro atributo que queremos recuperar do objeto de usuário, que é name.

Você pode acessar aqui para ver uma lista de atributos adicionais que podem ser recuperados de um objeto de usuário. Agora você deve ver algo assim depois de executá-lo:

imagem-18

Imagem do Autor.

Tudo bem, isso praticamente encerra a implementação do Tweepy. Apenas lembre-se de que há um limite para o número de tweets que você pode recuperar, e você não pode recuperar tweets com mais de 7 dias usando o Tweepy.

Como usar o Snscrape para raspar tweets

Como mencionei anteriormente, o Snscrape não requer credenciais do Twitter (chave de API) para acessá-lo. Também não há limite para o número de tweets que você pode buscar.

Para este exemplo, porém, apenas recuperaremos os mesmos tweets do exemplo anterior, mas usando o Snscrape.

Para usar o Snscrape, devemos primeiro instalar sua biblioteca em nosso PC. Você pode fazer isso digitando:

pip3 install git+https://github.com/JustAnotherArchivist/snscrape.git

Como raspar tweets de um usuário com Snscrape

O Snscrape inclui dois métodos para obter tweets do Twitter: a interface de linha de comando (CLI) e um Python Wrapper. Apenas tenha em mente que o Python Wrapper não está documentado no momento – mas ainda podemos nos virar com tentativa e erro.

Neste exemplo, usaremos o Python Wrapper porque é mais intuitivo que o método CLI. Mas se você ficar preso a algum código, sempre poderá recorrer à comunidade do GitHub para obter assistência. Os colaboradores terão prazer em ajudá-lo.

Para recuperar tweets de um usuário específico, podemos fazer o seguinte:

import snscrape.modules.twitter as sntwitter
import pandas as pd

# Created a list to append all tweet attributes(data)
attributes_container = []

# Using TwitterSearchScraper to scrape data and append tweets to list
for i,tweet in enumerate(sntwitter.TwitterSearchScraper('from:john').get_items()):
    if i>100:
        break
    attributes_container.append([tweet.date, tweet.likeCount, tweet.sourceLabel, tweet.content])
    
# Creating a dataframe from the tweets list above 
tweets_df = pd.DataFrame(attributes_container, columns=["Date Created", "Number of Likes", "Source of Tweet", "Tweets"])

Vamos revisar alguns dos códigos que você pode não entender à primeira vista:

for i,tweet in enumerate(sntwitter.TwitterSearchScraper('from:john').get_items()):
    if i>100:
        break
    attributes_container.append([tweet.date, tweet.likeCount, tweet.sourceLabel, tweet.content])
    
  
# Creating a dataframe from the tweets list above 
tweets_df = pd.DataFrame(attributes_container, columns=["Date Created", "Number of Likes", "Source of Tweet", "Tweets"])

No código acima, o que o sntwitter.TwitterSearchScaperfaz é retornar um objeto de tweets do nome do usuário que passamos para ele (que é john).

Como mencionei anteriormente, o Snscrape não tem limites no número de tweets, então ele retornará quantos tweets desse usuário. Para ajudar com isso, precisamos adicionar a função enumerate que irá percorrer o objeto e adicionar um contador para que possamos acessar os 100 tweets mais recentes do usuário.

Você pode ver que a sintaxe de atributos que obtemos de cada tweet se parece com a do Tweepy. Esta é a lista de atributos que podemos obter do tweet do Snscrape, com curadoria de Martin Beck.

Sns.Scrape

Crédito: Martin Beck

Mais atributos podem ser adicionados, pois a biblioteca Snscrape ainda está em desenvolvimento. Como por exemplo na imagem acima, sourcefoi substituído por sourceLabel. Se você passar apenas sourceele retornará um objeto.

Se você executar o código acima, deverá ver algo assim também:

imagem-19

Imagem do autor

Agora vamos fazer o mesmo para raspagem por pesquisa.

Como raspar tweets de uma pesquisa de texto com Snscrape

import snscrape.modules.twitter as sntwitter
import pandas as pd

# Creating list to append tweet data to
attributes_container = []

# Using TwitterSearchScraper to scrape data and append tweets to list
for i,tweet in enumerate(sntwitter.TwitterSearchScraper('sex for grades since:2021-07-05 until:2022-07-06').get_items()):
    if i>150:
        break
    attributes_container.append([tweet.user.username, tweet.date, tweet.likeCount, tweet.sourceLabel, tweet.content])
    
# Creating a dataframe to load the list
tweets_df = pd.DataFrame(attributes_container, columns=["User", "Date Created", "Number of Likes", "Source of Tweet", "Tweet"])

Novamente, você pode acessar muitos dados históricos usando o Snscrape (ao contrário do Tweepy, pois sua API padrão não pode exceder 7 dias. A API premium é de 30 dias). Assim, podemos passar a data a partir da qual queremos iniciar a pesquisa e a data em que queremos que ela termine no sntwitter.TwitterSearchScraper()método.

O que fizemos no código anterior é basicamente o que discutimos antes. A única coisa a ter em mente é que até funciona de forma semelhante à função range em Python (ou seja, exclui o último inteiro). Portanto, se você deseja obter tweets de hoje, precisa incluir o dia depois de hoje no parâmetro "até".

imagem-21

Imagem do Autor.

Agora você também sabe como raspar tweets com o Snscrape!

Quando usar cada abordagem

Agora que vimos como cada método funciona, você deve estar se perguntando quando usar qual.

Bem, não existe uma regra universal para quando utilizar cada método. Tudo se resume a uma preferência de assunto e seu caso de uso.

Se você deseja adquirir um número infinito de tweets, deve usar o Snscrape. Mas se você quiser usar recursos extras que o Snscrape não pode fornecer (como geolocalização, por exemplo), você deve definitivamente usar o Tweepy. Ele é integrado diretamente com a API do Twitter e oferece funcionalidade completa.

Mesmo assim, o Snscrape é o método mais comumente usado para raspagem básica.

Conclusão

Neste artigo, aprendemos como extrair dados do Python usando Tweepy e Snscrape. Mas esta foi apenas uma breve visão geral de como cada abordagem funciona. Você pode aprender mais explorando a web para obter informações adicionais.

Incluí alguns recursos úteis que você pode usar se precisar de informações adicionais. Obrigado por ler.

 Fonte: https://www.freecodecamp.org/news/python-web-scraping-tutorial/ 

#python #web