Python automated processing of mobile phone verification code

Mobile Verification Code is a common authentication method and is widely used in scenarios such as user registration, login, and transaction confirmation. Automatic processing of mobile phone verification codes is of great significance in applications such as data capture, automated testing, and batch registration. However, it should be noted that unauthorized automated acquisition and use of verification codes may violate relevant laws and regulations and the terms of use of the website. Therefore, when performing relevant operations, please make sure to comply with laws and regulations and obtain the necessary authorizations.

This article will introduce in detail how to use Python to automatically process mobile phone verification codes, including the following content:

Get mobile phone verification code
Analysis and extraction of verification codes
Automatically enter verification code
Things to note in practical applications

1. Obtain mobile phone verification code

1.1 Receive verification code through SMS

The most common way to obtain is to receive verification codes through text messages. The key to automated processing lies in how to automatically read SMS content.

1.2 Use third-party SMS reception services

Some third-party services (such as Twilio, Nexmo, etc.) provide API interfaces that can receive and read SMS content. These services usually require registering an account and obtaining an API key.

Example: Use Twilio to receive text messages

from  import Client

# Twilio Account Informationaccount_sid = 'YOUR_ACCOUNT_SID'
auth_token = 'YOUR_AUTH_TOKEN'
client = Client(account_sid, auth_token)

# Get the latest text messagemessage = (limit=1)[0]
print(f"Verification code: {}")

# Extract the verification code (assuming the verification code is 6 digits)import re
verification_code = (r'\b\d{6}\b', latest_message).group()
print(f"提取的Verification code: {verification_code}")

1.3 Read SMS by using ADB

Android Debug Bridge (ADB) can read the text message content on the connected device. Steps:

Connect your phone and enable USB debugging.
Install the ADB tool and configure environment variables.
Use the ADB command to read the text message.

Sample code:

import subprocess
import re

def get_sms_verification_code():
    # Use ADB command to read text messages    result = (['adb', 'shell', 'content', 'query', '--uri', 'content://sms/inbox'], capture_output=True, text=True)
    messages = ()
    
    # Regular expression matching verification code (assuming that verification code is 4-6 digits)    pattern = (r'Verification code[:：]\s*(\d{4,6})')
    for message in messages:
        match = (message)
        if match:
            return (1)
    return None

code = get_sms_verification_code()
if code:
    print(f"Verification code obtained: [code]")
else:
    print("No verification code found")

1.4 Obtain verification code through API

Some applications or websites provide API interfaces that can directly obtain verification codes. This approach usually requires developer permissions or specific access keys.

Example:

import requests

def get_verification_code(api_url, api_key):
    headers = {
        'Authorization': f'Bearer {api_key}'
    }
    response = (api_url, headers=headers)
    if response.status_code == 200:
        data = ()
        return ('code')
    else:
        print(f"Failed to obtain verification code: {response.status_code}")
        return None

api_url = '/get_code'
api_key = 'YOUR_API_KEY'
code = get_verification_code(api_url, api_key)
if code:
    print(f"Verification code obtained: [code]")

1.5 Receive verification codes by email

Read emails using IMAP protocol

1. Install imaplib and email libraries (provided in Python).
2. Use the following code to read the email and extract the verification code:

import imaplib
import email
import re

# Email Configurationemail_user = 'your_email@'
email_pass = 'your_email_password'
imap_server = ''

# Connect to emailmail = imaplib.IMAP4_SSL(imap_server)
(email_user, email_pass)
('inbox')

# Search for the latest emailsstatus, messages = (None, 'ALL')
latest_email_id = messages[0].split()[-1]

# Get email contentstatus, msg_data = (latest_email_id, '(RFC822)')
raw_email = msg_data[0][1]
msg = email.message_from_bytes(raw_email)

# Extract email textif msg.is_multipart():
    for part in ():
        content_type = part.get_content_type()
        if content_type == 'text/plain':
            body = part.get_payload(decode=True).decode()
            break
else:
    body = msg.get_payload(decode=True).decode()

# Extract the verification code (assuming the verification code is 6 digits)verification_code = (r'\b\d{6}\b', body).group()
print(f"Extracted verification code: {verification_code}")

2. Analyze and extract verification codes

After obtaining the verification code, it usually needs to be parsed and extracted. This step depends on the format and transmission method of the verification code.

2.1 Regular expression extraction

Use regular expressions to extract verification codes from text messages or other text.

import re

def extract_code(text):
    pattern = (r'Verification code[:：]\s*(\d{4,6})')
    match = (text)
    if match:
        return (1)
    return None

text = "Your verification code is: 123456, please use it within 5 minutes."
code = extract_code(text)
print(f"Extracted verification code: [code]")

2.2 JSON parsing

If the verification code is returned in JSON format through the API, it can be parsed using the json module.

import json

def parse_json_code(json_data):
    data = (json_data)
    return ('code')

json_data = '{"code": "654321", "expiry": 300}'
code = parse_json_code(json_data)
print(f"Verification code parsed: [code]")

3. Automatically enter verification code

After obtaining and extracting the verification code, it can be automatically entered into the target application or website. This usually involves simulating user actions such as filling out forms, clicking buttons, etc.

3.1 Automating Web Applications with Selenium

Example: Automatically log in and enter verification code

from selenium import webdriver
import time

# Initialize the browser driverdriver = (executable_path='path/to/chromedriver')

# Open the login page('/login')

# Enter username and passworddriver.find_element_by_id('username').send_keys('your_username')
driver.find_element_by_id('password').send_keys('your_password')

# Get the verification code and entercode = get_sms_verification_code()  # Use the above method to obtain the verification codedriver.find_element_by_id('verification_code').send_keys(code)

# Submit the formdriver.find_element_by_id('login_button').click()

# Wait for login to complete(5)

# Close the browser()

3.2 Automating mobile applications with Appium

Example: Automatically fill in the verification code in the mobile application

from appium import webdriver
import time

desired_caps = {
    'platformName': 'Android',
    'deviceName': 'YourDeviceName',
    'appPackage': '',
    'appActivity': '.MainActivity',
}

driver = ('http://localhost:4723/wd/hub', desired_caps)

# Wait for the application to load(5)

# enter confirmation codecode = get_sms_verification_code()
driver.find_element_by_id(':id/verification_code').send_keys(code)

# Submit verification codedriver.find_element_by_id(':id/submit_button').click()

# Wait for the operation to complete(5)

()

3.3 Application automation

Use PyAutoGUI or Appium to automate desktop or mobile application operations. Install PyAutoGUI:pip install pyautogui。

Examples of using PyAutoGUI to enter verification code are as follows:

import pyautogui
import time

# Wait for the user to switch to the target application(5)

# enter confirmation codeverification_code = '123456'  # Assuming the extracted verification code(verification_code)

# Press Enter to submit('enter')

4. Things to note in practical application

1 Law and morality

Authorization and Compliance: Ensure that you have obtained authorization from the relevant website or application before performing automated operations to avoid violations of the Terms of Use.
Privacy protection: When processing user verification codes, you must comply with data privacy regulations to protect user information security.

2 Anti-automation mechanism

Verification code type: Different types of verification codes (such as graphic verification codes, sliding verification codes, reCAPTCHA, etc.) may require different processing methods.

Frequency Limit: Avoid frequent requests for verification codes to prevent them from being identified as malicious behavior, resulting in account banning or other restrictions.

Dynamic verification: Some websites use dynamic verification code mechanisms, which may require the combination of browser simulation, behavioral analysis and other technologies.

3. Validity period of verification code

The verification code usually has a validity period, and the automated script needs to complete the input operation within the validity period. It is recommended to use the verification code as soon as possible after obtaining it and deal with the expiration of the verification code.

4 Error handling and retry mechanism

In actual applications, you may encounter verification code acquisition failure, input errors, etc. It is recommended to add error handling and retry mechanisms to the script to improve the stability of the automated process.

Example: Retry mechanism

def retry(max_retries=3, delay=5):
    def decorator(func):
        def wrapper(*args, **kwargs):
            retries = 0
            while retries &lt; max_retries:
                result = func(*args, **kwargs)
                if result is not None:
                    return result
                retries += 1
                (delay)
            raise Exception("Maximum retry count")
        return wrapper
    return decorator

@retry(max_retries=3, delay=5)
def get_verification_code_with_retry():
    return get_sms_verification_code()

5. Summary

Automatic processing of mobile phone verification codes has important application value in improving efficiency and user experience. However, during the implementation process, strict compliance with laws and regulations, respect user privacy, and take necessary security measures. Through reasonable technical means and strategies, an efficient and stable automated verification code processing process can be achieved.

Notes:

Learning and research: Continue to pay attention to the development of verification code technology and understand the latest protection mechanisms and bypass methods.

Tools and Framework: Familiar with and master relevant automation tools and frameworks, such as Selenium, Appium, Twilio, etc., to improve development efficiency.

Security: Ensure the security of automated scripts and prevent verification codes from being maliciously exploited.

Through the above methods and precautions, the automated processing of mobile phone verification codes can be effectively realized to meet the needs of various application scenarios.

The above is the detailed content of Python's automated processing of mobile phone verification codes. For more information about Python's mobile phone verification codes, please follow my other related articles!