python अजगर के साथ हस्ताक्षरित फाइल को सत्यापित करने में समस्याएं



google-app-engine openssl (1)

मैं OpenSSL और पायथन का उपयोग करके एक हस्ताक्षरित फाइल बनाने की कोशिश कर रहा हूं, और मुझे कोई त्रुटि नहीं मिली है, लेकिन प्रक्रिया ठीक से काम नहीं कर रही है और मुझे इसका कारण नहीं मिल रहा है।

नीचे फ़ाइल पर हस्ताक्षर करने और हस्ताक्षर की जांच करने के लिए मेरा चरण-दर-चरण है:

  1. पहले मैं कमांड लाइन में CRT बना रहा हूँ

    openssl req -nodes -x509 -sha256 -newkey rsa:4096 -keyout "cert.key" -out "cert.crt" -subj "/C=BR/ST=SP/L=SP/O=Company/OU=IT Dept/CN=cert"

इस बिंदु पर, मेरे पास दो फ़ाइलें हैं: cert.key और cert.crt

  1. फ़ाइल को नीचे लिखे एक पायथन स्क्रिप्ट का उपयोग करें:

    import os.path
    from Crypto.PublicKey import RSA
    from Crypto.Signature import PKCS1_v1_5
    from Crypto.Hash import SHA256
    from base64 import b64encode, b64decode
    
    def __init__(self):
        folder = os.path.dirname(os.path.realpath(__file__))
        file_path = os.path.join(folder, '../static/cert.key')
        self.key = open(file_path, "r").read()
    
    def sign_data(self, my_file):
        rsakey = RSA.importKey(self.key) # I opened the cert.key in __init__
        signer = PKCS1_v1_5.new(rsakey)
        digest = SHA256.new()
    
        digest.update(my_file)
        sign = signer.sign(digest)
    
        return sign, b64encode(sign)

सभी काम ठीक और फ़ाइलें सहेजने के बाद, मेरे पास तीन अन्य फाइलें हैं: my_file.csv (मूल एक), my_file.txt.sha256 और my_file.txt.sha256.base64 . my_file.txt.sha256.base64 इस बिंदु पर, मैं बेस 64 फाइल को डीकोड कर सकता हूं और हस्ताक्षरित एक के साथ तुलना कर सकता हूं और दोनों ठीक हैं।

समस्या तब होती है जब मैं निम्नलिखित कमांड का उपयोग करके हस्ताक्षर को सत्यापित करने का प्रयास करता हूं:

`openssl dgst -sha256 -verify  <(openssl x509 -in "cert.crt"  -pubkey -noout) -signature my_file.txt.sha256 my_file.csv`

इस बिंदु पर मुझे हमेशा "सत्यापन विफलता" प्राप्त होता है और समझ में नहीं आता कि क्यों

शायद समस्या मेरी पायथन के ज्ञान की कमी है, क्योंकि जब मैं निम्नलिखित कमांड का उपयोग करते हुए फ़ाइल पर हस्ताक्षर करता हूं (चरण 1 के बाद और 2 में वर्णित पायथन स्क्रिप्ट का उपयोग करने से पहले), तो वही सत्यापन ठीक काम करता है

openssl dgst -sha256 -sign "cert.key" -out my_file.txt.sha256 my_file.csv

क्या मैं गलत हूं?

अद्यतन करें

टिप्पणियों के आधार पर, मैंने अजगर 2.7 के साथ स्थानीय आभासी नेटवर्क में स्क्रिप्ट की कोशिश की और यह काम किया, इसलिए समस्या पढ़ने / लिखने के कार्यों में होनी चाहिए।

मैं इस स्क्रिप्टन को पूरी तरह से स्क्रिप्ट के साथ अद्यतन कर रहा / रही हूं, जिसमें पढ़ने / लिखने के संचालन शामिल हैं, क्योंकि मैं इसे स्थानीय रूप से चला सकता हूं, लेकिन मुझे अभी भी GAE पर्यावरण में कोई त्रुटि नहीं मिली है और यह समझ में नहीं आ रहा है कि क्यों

पहला कदम सीएसवी निर्माण और भंडारण के नीचे स्क्रिप्ट के साथ Google संग्रहण (बाल्टी) में है

import logging
import string
import cloudstorage as gcs
from google.appengine.api import app_identity

def create_csv_file(self, filename, cursor=None):    
    filename = '/' + self.bucket_name + filename
    try:
        write_retry_params = gcs.RetryParams(backoff_factor=1.1)
        # the cursor stores a MySQL result set
        if cursor is not None:
            gcs_file = gcs.open(filename,
                                'w',
                                content_type='text/csv',
                                retry_params=write_retry_params)
            for row in cursor:
                gcs_file.write(','.join(map(str, row)) + '\n')
            gcs_file.close()
    except Exception as ex:
        logging.critical("Problem to write in th GC Storage with the exception:{}".format(ex))
        raise ex

यह ठीक काम करता है और Google स्टोरेज के अंदर सही पथ में एक सीएसवी स्टोर करता है। उस भाग के बाद, अगली पठन / लिखने की प्रक्रिया फ़ाइल के हस्ताक्षर है।

def cert_file(self, original_filename):
    filename = '/' + self.bucket_name + original_filename
    cert = Cert() # This class just has one method, that is that described in my original question and is used to sign the file.

    with gcs.open(filename) as cloudstorage_file:
        cloudstorage_file.seek(-1024, os.SEEK_END)
        signed_file, encoded_signed_file = cert.sign_data(cloudstorage_file.read()) #the method to sign the file
    signature_content = encoded_signed_file

    signed_file_name = string.replace(original_filename, '.csv', '.txt.sha256')
    encoded_signed_file_name = string.replace(signed_file_name, '.txt.sha256', '.txt.sha256.base64')

    self.inner_upload_file(signed_file, signed_file_name)
    self.inner_upload_file(encoded_signed_file, encoded_signed_file_name)

    return signed_file_name, encoded_signed_file_name, signature_content

inner_upload_file , बस एक ही बाल्टी में नई फाइलें सहेजें:

def inner_upload_file(self, file_data, filename):
    filename = '/' + self.bucket_name + filename
    try:
        write_retry_params = gcs.RetryParams(backoff_factor=1.1)
        gcs_file = gcs.open(filename,
                            'w',
                            content_type='application/octet-stream',
                            retry_params=write_retry_params)
        gcs_file.write(file_data)
        gcs_file.close()
    except Exception as ex:
        logging.critical("Problem to write in th GC Storage with the exception:{}".format(ex))
        raise ex

संदर्भ के लिए यहां app.yaml है कमांड लाइन द्वारा उत्पन्न cert.key और cert.crt ऐप फ़ोल्डर के अंदर एक स्थिर फ़ोल्डर में संग्रहित किया जाता है (वही निर्देशिका जहां मेरा ऐप है.यामएल है)।

2 अद्यतन करें

टिप्पणियों के बाद, मैंने स्थानीय रूप से हस्ताक्षर प्रक्रिया को चलाने की कोशिश की और फिर फ़ाइलों की तुलना करें नीचे चरण-दर-सेटप और परिणाम हैं।

सबसे पहले, मैंने python sign.py file_name रूप में चलाने के लिए हस्ताक्षर प्रक्रिया को रूपांतरित किया।

#!/usr/bin/python

import sys
import os
from Crypto.PublicKey import RSA
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA256
from base64 import b64encode, b64decode

file_path = 'static/cert.key'
key = open(file_path, "rb").read()

rsakey = RSA.importKey(key)
signer = PKCS1_v1_5.new(rsakey)
digest = SHA256.new()
file_object  = open(sys.argv[1], "r")
digest.update(file_object.read())
sign = signer.sign(digest)
signed_path = "signed"
f = open(signed_path + '.txt.sha256', 'w')
f.write(sign)
f.close()
f2 = open(signed_path + '.txt.sha256.base64', 'w')
f2.write(b64encode(sign))
f2.close()

मैंने स्वचालित proccess चलाया जो हस्ताक्षरित फ़ाइल जीसीएस की बाल्टी में सहेजी (मूल सीएसवी फाइल के साथ) इसके बाद मैं जीसीएस के लिए Google वेब पैनल के माध्यम से दोनों फाइल डाउनलोड करता हूं।

मैंने कमांड python sign.py gcs_file_original.csv को पाइथन 2.7.10 के साथ एक python sign.py gcs_file_original.csv में python sign.py gcs_file_original.csv था जो कि मैंने सिर्फ सीएसवी फ़ाइल का उपयोग किया था।

उसके बाद, मैंने cmp -b gcs_signed.txt.sha256 locally_signed.txt.sha256 साथ दो हस्ताक्षरित फाइलों की तुलना cmp -b gcs_signed.txt.sha256 locally_signed.txt.sha256 परिणामस्वरूप:

gcs_signed.txt.sha256 स्थानीय रूप से संसृत। txt.sha256 भिन्न: बाइट 1, पंक्ति 1 24 ^ टी 164 टी है

VisualBinaryDiff का उपयोग करना, परिणाम दो पूरी तरह से अलग फाइलों की तरह लग रहा है

अब, मुझे समस्या पता है, लेकिन इसे ठीक करने के बारे में कोई जानकारी नहीं है। यह समस्या बहुत चाल है।


आखिरकार मैंने समस्या पाया मैं openssl हस्ताक्षर प्रक्रिया में एक समस्या को खोजने में केंद्रित था और पुराने Ctrl + C / Ctrl + V समस्या पर ध्यान नहीं दिया।

परीक्षण उद्देश्यों के लिए, मैंने इस ट्यूटोरियल से 'जीसीएस से पढ़ें' उदाहरण की नकल की है।

जब मैंने परीक्षण को वास्तविक विश्व आवेदन पर ले जाया था, मैंने पृष्ठ को फिर से नहीं पढ़ा था और gcs_file.seek(-1024, os.SEEK_END) ध्यान नहीं दिया।

जैसा कि मैंने मूल प्रश्न में कहा था, मैं पायथन विशेषज्ञ नहीं हूं, लेकिन यह रेखा जीसीएस फ़ाइल का सिर्फ एक भाग पढ़ रही थी, इसलिए हस्ताक्षर वास्तव में मूल एक से भिन्न था।

बस मेरी रीडिंग विधियों की यह रेखा कटनी है और अब सभी ठीक काम करता है





google-cloud-storage