Python: Bỏ qua lỗi 'Phần đệm không chính xác' khi giải mã base64

Tôi có một số dữ liệu được mã hóa base64 mà tôi muốn chuyển đổi lại thành nhị phân ngay cả khi có lỗi đệm trong đó. Nếu tôi sử dụng

base64.decodestring(b64_string)

nó gây ra lỗi 'Phần đệm không chính xác'. Có cách nào khác không?

CẬP NHẬT: Cảm ơn vì tất cả các phản hồi. Thành thật mà nói, tất cả các phương pháp được đề cập nghe có vẻ hơi rắc rối và thiếu sót vì vậy tôi quyết định thử openssl. Lệnh sau có tác dụng:

openssl enc -d -base64 -in b64string -out binary_data

Như đã nói trong các câu trả lời khác, có nhiều cách khác nhau mà dữ liệu base64 có thể bị hỏng.

Tuy nhiên, như Wikipedia cho biết, việc xóa phần đệm (các ký tự '=' ở cuối dữ liệu được mã hóa base64) là "không mất dữ liệu":

Từ quan điểm lý thuyết, ký tự đệm là không cần thiết, vì số byte bị thiếu có thể được tính từ số chữ số Base64.

Vì vậy, nếu đây thực sự là điều duy nhất "sai" với dữ liệu base64 của bạn, thì phần đệm chỉ có thể được thêm lại. Tôi đã nghĩ ra điều này để có thể phân tích cú pháp URL "dữ liệu" trong WeasyPrint, một số trong số đó là base64 mà không có phần đệm:

import base64
import re

def decode_base64(data, altchars=b'+/'):
    """Decode base64, padding being optional.

    :param data: Base64 data as an ASCII byte string
    :returns: The decoded byte string.

    """
    data = re.sub(rb'[^a-zA-Z0-9%s]+' % altchars, b'', data)  # normalize
    missing_padding = len(data) % 4
    if missing_padding:
        data += b'='* (4 - missing_padding)
    return base64.b64decode(data, altchars)

Các thử nghiệm cho chức năng này: weasyprint / tests / test_css.py # L68

Chỉ cần thêm đệm theo yêu cầu. Tuy nhiên, chú ý đến cảnh báo của Michael.

b64_string += "=" * ((4 - len(b64_string) % 4) % 4) #ugh

Có vẻ như bạn chỉ cần thêm đệm vào byte của mình trước khi giải mã. Có nhiều câu trả lời khác cho câu hỏi này, nhưng tôi muốn chỉ ra rằng (ít nhất là trong Python 3.x) base64.b64decodesẽ cắt bớt bất kỳ phần đệm thừa nào, miễn là có đủ ngay từ đầu.

Vì vậy, một cái gì đó như: b'abc='hoạt động tốt như b'abc=='(như vậy b'abc=====').

Điều này có nghĩa là bạn chỉ có thể thêm số lượng ký tự đệm tối đa mà bạn cần — là ba ( b'===') —và base64 sẽ cắt bớt những ký tự không cần thiết.

Điều này cho phép bạn viết:

base64.b64decode(s + b'===')

đơn giản hơn:

base64.b64decode(s + b'=' * (-len(s) % 4))

"Phần đệm không chính xác" có thể không chỉ có nghĩa là "phần đệm bị thiếu" mà còn (tin hay không) "phần đệm không chính xác".

Nếu các phương pháp "thêm phần đệm" được đề xuất không hoạt động, hãy thử xóa một số byte ở cuối:

lens = len(strg)
lenx = lens - (lens % 4 if lens % 4 else 4)
try:
    result = base64.decodestring(strg[:lenx])
except etc

Cập nhật: Mọi thao tác liên quan đến việc thêm phần đệm hoặc xóa các byte có thể không hợp lệ khỏi phần cuối nên được thực hiện SAU KHI xóa bất kỳ khoảng trắng nào, nếu không các phép tính độ dài sẽ bị ảnh hưởng.

Sẽ là một ý kiến ​​hay nếu bạn cho chúng tôi xem một mẫu (ngắn) dữ liệu mà bạn cần khôi phục. Chỉnh sửa câu hỏi của bạn và sao chép / dán kết quả của print repr(sample) .

Cập nhật 2: Có thể quá trình mã hóa đã được thực hiện theo cách an toàn với url. Nếu đúng như vậy, bạn sẽ có thể thấy các ký tự dấu trừ và gạch dưới trong dữ liệu của mình và bạn sẽ có thể giải mã nó bằng cách sử dụngbase64.b64decode(strg, '-_')

Nếu bạn không thể nhìn thấy các ký tự dấu trừ và gạch dưới trong dữ liệu của mình, nhưng có thể thấy các ký tự dấu cộng và dấu gạch chéo, thì bạn đang gặp một số vấn đề khác và có thể cần thủ thuật thêm phần đệm hoặc xóa dấu gạch ngang.

Nếu bạn không thể thấy dấu trừ, dấu gạch dưới, dấu cộng và dấu gạch chéo trong dữ liệu của mình, thì bạn cần xác định hai ký tự thay thế; chúng sẽ là những cái không có trong [A-Za-z0-9]. Sau đó, bạn sẽ cần thử nghiệm để xem chúng cần được sử dụng theo thứ tự nào trong lập luận thứ 2 củabase64.b64decode()

Cập nhật 3 : Nếu dữ liệu của bạn là "công ty bí mật":
(a) bạn nên nói như vậy lên phía trước
(b) chúng ta có thể khám phá những con đường khác trong việc tìm hiểu vấn đề, đó là rất có khả năng có liên quan đến những gì nhân vật được sử dụng thay cho +và /trong bảng chữ cái mã hóa, hoặc theo định dạng khác hoặc các ký tự không liên quan.

Một trong những cách như vậy sẽ là kiểm tra những ký tự không "chuẩn" nào trong dữ liệu của bạn, ví dụ:

from collections import defaultdict
d = defaultdict(int)
import string
s = set(string.ascii_letters + string.digits)
for c in your_data:
   if c not in s:
      d[c] += 1
print d

Sử dụng

string += '=' * (-len(string) % 4)  # restore stripped '='s

Tín dụng đi đến một bình luận ở đâu đó ở đây.

>>> import base64

>>> enc = base64.b64encode('1')

>>> enc
>>> 'MQ=='

>>> base64.b64decode(enc)
>>> '1'

>>> enc = enc.rstrip('=')

>>> enc
>>> 'MQ'

>>> base64.b64decode(enc)
...
TypeError: Incorrect padding

>>> base64.b64decode(enc + '=' * (-len(enc) % 4))
>>> '1'

>>> 

Nếu có lỗi đệm, điều đó có thể có nghĩa là chuỗi của bạn bị hỏng; chuỗi được mã hóa base64 phải có bội số của bốn chiều dài. Bạn có thể thử tự thêm ký tự đệm ( =) để tạo chuỗi thành bội số của bốn, nhưng nó phải có ký tự đó trừ khi có gì đó sai

Kiểm tra tài liệu về nguồn dữ liệu bạn đang cố giải mã. Có thể là bạn muốn sử dụng base64.urlsafe_b64decode(s)thay vì base64.b64decode(s)? Đó là một lý do khiến bạn có thể thấy thông báo lỗi này.

Giải mã chuỗi s bằng bảng chữ cái an toàn cho URL, bảng này thay thế - thay vì + và _ thay vì / trong bảng chữ cái Base64 tiêu chuẩn.

Ví dụ, đây là trường hợp của các API Google khác nhau, như Bộ công cụ nhận dạng của Google và tải trọng Gmail.

Thêm phần đệm thì khá là ... khó hiểu. Đây là chức năng tôi đã viết với sự trợ giúp của các nhận xét trong chủ đề này cũng như trang wiki cho base64 (nó hữu ích một cách đáng ngạc nhiên) https://en.wikipedia.org/wiki/Base64#Padding .

import logging
import base64
def base64_decode(s):
    """Add missing padding to string and return the decoded base64 string."""
    log = logging.getLogger()
    s = str(s).strip()
    try:
        return base64.b64decode(s)
    except TypeError:
        padding = len(s) % 4
        if padding == 1:
            log.error("Invalid base64 string: {}".format(s))
            return ''
        elif padding == 2:
            s += b'=='
        elif padding == 3:
            s += b'='
        return base64.b64decode(s)

Bạn chỉ có thể sử dụng base64.urlsafe_b64decode(data)nếu bạn đang cố gắng giải mã một hình ảnh web. Nó sẽ tự động chăm sóc phần đệm.

Có hai cách để sửa dữ liệu đầu vào được mô tả ở đây, hoặc cụ thể hơn và phù hợp với OP, để làm cho phương thức b64decode của mô-đun Python, base64 có thể xử lý dữ liệu đầu vào thành một thứ gì đó mà không tạo ra một ngoại lệ không bắt được:

1. Nối == vào cuối dữ liệu đầu vào và gọi base64.b64decode (...)

2. Nếu điều đó làm nảy sinh một ngoại lệ, thì

   Tôi. Nắm bắt nó thông qua thử / ngoại trừ,

   ii. (R?) Loại bỏ bất kỳ ký tự = nào khỏi dữ liệu đầu vào (NB điều này có thể không cần thiết),

   iii. Nối A == vào dữ liệu đầu vào (A == đến P == sẽ hoạt động),

   iv. Gọi base64.b64decode (...) với A == - dữ liệu đầu vào được nối thêm

Kết quả từ Mục 1. hoặc Mục 2. ở trên sẽ mang lại kết quả mong muốn.

Cảnh báo

Điều này không đảm bảo kết quả được giải mã sẽ là những gì được mã hóa ban đầu, nhưng (đôi khi?) Cung cấp cho OP đủ để làm việc với:

Ngay cả khi bị hỏng, tôi muốn quay lại hệ nhị phân vì tôi vẫn có thể nhận được một số thông tin hữu ích từ luồng ASN.1 ").

Xem những gì chúng tôi biết và giả định bên dưới.

TL; DR

Từ một số thử nghiệm nhanh của base64.b64decode (...)

3. có vẻ như nó bỏ qua các ký tự không phải [A-Za-z0-9 + /]; bao gồm việc bỏ qua = s trừ khi chúng là (các) ký tự cuối cùng trong nhóm bốn ký tự được phân tích cú pháp, trong trường hợp đó dấu = kết thúc quá trình giải mã (a = b = c = d = cho kết quả giống như abc = và a = = b == c == cho kết quả tương tự như ab ==).

4. Có vẻ như tất cả các ký tự được thêm vào đều bị bỏ qua sau điểm mà base64.b64decode (...) kết thúc giải mã, ví dụ từ an = là ký tự thứ tư trong một nhóm.

Như đã lưu ý trong một số nhận xét ở trên, không có hoặc một hoặc hai = s khoảng đệm được yêu cầu ở cuối dữ liệu đầu vào khi giá trị [số ký tự được phân tích cú pháp cho điểm đó modulo 4] là 0 hoặc 3, hoặc 2, tương ứng. Vì vậy, từ mục 3. và 4. ở trên, việc thêm hai hoặc nhiều = s vào dữ liệu đầu vào sẽ khắc phục mọi sự cố [Phần đệm không chính xác] trong những trường hợp đó.

TUY NHIÊN, việc giải mã không thể xử lý trường hợp [tổng số ký tự được phân tích cú pháp modulo 4] là 1, bởi vì nó cần ít nhất hai ký tự được mã hóa để đại diện cho byte được giải mã đầu tiên trong nhóm ba byte được giải mã. Trong dữ liệu đầu vào được mã hóa không bị hỏng, trường hợp này [N modulo 4] = 1 không bao giờ xảy ra, nhưng như OP đã nói rằng các ký tự có thể bị thiếu, nó có thể xảy ra ở đây. Đó là lý do tại sao đơn giản là thêm = s sẽ không luôn hoạt động và tại sao thêm A == sẽ hoạt động khi thêm == thì không. NB Sử dụng [A] là tất cả, trừ tùy ý: nó chỉ thêm các bit đã xóa (không) vào phần đã giải mã, có thể đúng hoặc không, nhưng đối tượng ở đây không phải là tính đúng mà là hoàn thành bởi base64.b64decode (...) sans exceptions .

Những gì chúng tôi biết từ OP và đặc biệt là các nhận xét sau đó là

• Người ta nghi ngờ rằng có thiếu dữ liệu (ký tự) trong dữ liệu đầu vào được mã hóa Base64
• Mã hóa Base64 sử dụng 64 giá trị vị trí tiêu chuẩn cộng với phần đệm: AZ; az; 0-9; +; /; = là phần đệm. Điều này được xác nhận, hoặc ít nhất là gợi ý, bởi thực tế là openssl enc ...hoạt động.

Giả định

• Dữ liệu đầu vào chỉ chứa dữ liệu ASCII 7-bit
• Loại tham nhũng duy nhất là thiếu dữ liệu đầu vào được mã hóa
• OP không quan tâm đến dữ liệu đầu ra được giải mã tại bất kỳ thời điểm nào sau đó tương ứng với bất kỳ dữ liệu đầu vào được mã hóa nào bị thiếu

Github

Đây là một trình bao bọc để triển khai giải pháp này:

https://github.com/drbitboy/missing_b64

Lỗi đệm không chính xác là do đôi khi, siêu dữ liệu cũng có trong chuỗi được mã hóa Nếu chuỗi của bạn trông giống như: 'data: image / png; base64, ... base 64 things ....' thì bạn cần xóa phần đầu tiên một phần trước khi giải mã nó.

Giả sử bạn có chuỗi mã hóa image base64, sau đó thử đoạn mã bên dưới ..

from PIL import Image
from io import BytesIO
from base64 import b64decode
imagestr = 'data:image/png;base64,...base 64 stuff....'
im = Image.open(BytesIO(b64decode(imagestr.split(',')[1])))
im.save("image.png")

Chỉ cần thêm các ký tự bổ sung như "=" hoặc bất kỳ ký tự nào khác và đặt nó thành bội số của 4 trước khi bạn thử giải mã giá trị chuỗi mục tiêu. Cái gì đó như;

if len(value) % 4 != 0: #check if multiple of 4
    while len(value) % 4 != 0:
        value = value + "="
    req_str = base64.b64decode(value)
else:
    req_str = base64.b64decode(value)

Trong trường hợp lỗi này đến từ máy chủ web: Hãy thử mã hóa url giá trị bài đăng của bạn. Tôi đang ĐĂNG qua "curl" và phát hiện ra rằng tôi không mã hóa url giá trị base64 của mình, vì vậy các ký tự như "+" không được thoát ra vì vậy logic giải mã url của máy chủ web tự động chạy giải mã url và chuyển đổi + thành dấu cách.

"+" là một ký tự base64 hợp lệ và có lẽ là ký tự duy nhất bị giải mã url không mong muốn.

Trong trường hợp của tôi, tôi gặp phải lỗi đó khi phân tích cú pháp email. Tôi đã nhận tệp đính kèm dưới dạng chuỗi base64 và giải nén nó qua re.search. Cuối cùng, có một chuỗi con bổ sung kỳ lạ ở cuối.

dHJhaWxlcgo8PCAvU2l6ZSAxNSAvUm9vdCAxIDAgUiAvSW5mbyAyIDAgUgovSUQgWyhcMDAyXDMz
MHtPcFwyNTZbezU/VzheXDM0MXFcMzExKShcMDAyXDMzMHtPcFwyNTZbezU/VzheXDM0MXFcMzEx
KV0KPj4Kc3RhcnR4cmVmCjY3MDEKJSVFT0YK

--_=ic0008m4wtZ4TqBFd+sXC8--

Khi tôi xóa --_=ic0008m4wtZ4TqBFd+sXC8--và tách chuỗi thì quá trình phân tích cú pháp đã được sửa lại.

Vì vậy, lời khuyên của tôi là hãy đảm bảo rằng bạn đang giải mã một chuỗi base64 chính xác.

Bạn nên sử dụng

base64.b64decode(b64_string, ' /')

Theo mặc định, các altchars là '+/'.

Tôi cũng gặp phải vấn đề này và không có gì hoạt động. Cuối cùng tôi đã tìm ra giải pháp phù hợp với mình. Tôi đã nén nội dung trong base64 và điều này xảy ra với 1 trong số một triệu bản ghi ...

Đây là một phiên bản của giải pháp được đề xuất bởi Simon Sapin.

Trong trường hợp phần đệm bị thiếu 3 thì tôi loại bỏ 3 ký tự cuối cùng.

Thay vì "0gA1RD5L / 9AUGtH9MzAwAAA =="

Chúng tôi nhận được "0gA1RD5L / 9AUGtH9MzAwAA"

        missing_padding = len(data) % 4
        if missing_padding == 3:
            data = data[0:-3]
        elif missing_padding != 0:
            print ("Missing padding : " + str(missing_padding))
            data += '=' * (4 - missing_padding)
        data_decoded = base64.b64decode(data)   

Theo câu trả lời này, Trailing As trong base64 lý do là nulls. Nhưng tôi vẫn không biết tại sao bộ mã hóa lại làm rối tung điều này ...