পাইক্রিপটো এএসই 256 ব্যবহার করে এনক্রিপ্ট করুন এবং ডিক্রিপ্ট করুন

Question

আমি পাইক্রিপ্টো ব্যবহার করে দুটি ফাংশন তৈরির চেষ্টা করছি যা দুটি পরামিতি গ্রহণ করে: বার্তা এবং কী এবং তারপরে বার্তাটি এনক্রিপ্ট / ডিক্রিপ্ট করে।

আমাকে সাহায্য করতে ওয়েবে আমি বেশ কয়েকটি লিঙ্ক পেয়েছি, তবে তাদের প্রত্যেকেরই ত্রুটি রয়েছে:

কোডকোলে এই একটি os.urandom ব্যবহার করে যা পাইক্রিপ্টো দ্বারা নিরুৎসাহিত।

তদুপরি, আমি ফাংশনটিতে যে কীটি দিচ্ছি তার সঠিক দৈর্ঘ্য প্রত্যাশার নিশ্চয়তা নেই। তা ঘটানোর জন্য আমি কী করতে পারি?

এছাড়াও, বেশ কয়েকটি মোড রয়েছে, কোনটি সুপারিশ করা হয়? আমি কী ব্যবহার করব জানি না: /

অবশেষে, আইভি ঠিক কী? এনক্রিপ্ট এবং ডিক্রিপ্ট করার জন্য আমি কি আলাদা আইভি সরবরাহ করতে পারি, বা এটি কি অন্যরকম ফলাফল হিসাবে ফিরে আসবে?

সম্পাদনা করুন : কোডটি সুরক্ষিত না হওয়ার কারণে অংশটি সরানো হয়েছে।

Comments

os.urandom হয় উৎসাহিত উপর PyCrypto ওয়েবসাইট। এটি মাইক্রোসফ্টের ক্রিপ্টজেনর্যান্ডম ফাংশনটি ব্যবহার করে যা একটি সিএসপিআরএনজি

— জোয়েল

বা /dev/urandomইউনিক্সে

— জোয়েল ভুম

কেবল স্পষ্ট করে বলতে, এই উদাহরণে পাসফ্রেজ হল কীটি যা 128, 192 বা 256 বিট (16, 24, বা 32 বাইট) হতে পারে

— চিহ্নিত করুন

এটি উল্লেখ করার মতো হতে পারে যে পাইক্রিপ্টো একটি মৃত প্রকল্প । সর্বশেষ প্রতিশ্রুতিটি ২০১৪ সালের । পাইক্রিপডোডোম একটি ভাল ড্রপ-ইন প্রতিস্থাপনের মতো দেখায়

— ওভারড্রাইভর

এই প্রশ্নটি পুরানো, তবে আমি উল্লেখ করতে চাই (২০২০ সালের মতো) পাইক্রিপ্টো সম্ভবত পুরানো এবং এখন আর সমর্থিত নয়। তাদের GitHub পৃষ্ঠা (এ খুঁজছি github.com/pycrypto/pycrypto ), মনে হচ্ছে তাদের শেষ কমিট 2014. ছিল আমি ক্রিপ্টোগ্রাফিক সফ্টওয়্যার যা আর অধীনে উন্নয়ন ব্যবহারের ধূর্ত হতে চাই

— irritable_phd_syndrom

Answer 1

এখানে আমার বাস্তবায়নটি রয়েছে এবং আমার জন্য কিছু সংশোধন করে কাজ করে এবং কী এবং গোপন বাক্যটির সারিবদ্ধকরণ 32 বাইট এবং আইভ থেকে 16 বাইটে বাড়িয়ে তোলে:

import base64
import hashlib
from Crypto import Random
from Crypto.Cipher import AES

class AESCipher(object):

    def __init__(self, key): 
        self.bs = AES.block_size
        self.key = hashlib.sha256(key.encode()).digest()

    def encrypt(self, raw):
        raw = self._pad(raw)
        iv = Random.new().read(AES.block_size)
        cipher = AES.new(self.key, AES.MODE_CBC, iv)
        return base64.b64encode(iv + cipher.encrypt(raw.encode()))

    def decrypt(self, enc):
        enc = base64.b64decode(enc)
        iv = enc[:AES.block_size]
        cipher = AES.new(self.key, AES.MODE_CBC, iv)
        return self._unpad(cipher.decrypt(enc[AES.block_size:])).decode('utf-8')

    def _pad(self, s):
        return s + (self.bs - len(s) % self.bs) * chr(self.bs - len(s) % self.bs)

    @staticmethod
    def _unpad(s):
        return s[:-ord(s[len(s)-1:])]

Comments

আমি জানি এটি কিছুক্ষণ হয়ে গেছে তবে আমি মনে করি এই প্রতিক্রিয়াটি কিছু বিভ্রান্তি ছড়িয়ে দিতে পারে। এই ফাংশনটি ইনপুট ডেটা প্যাড করতে 32 বাইট (256 বাইট) এর একটি ব্লক_ সাইজ ব্যবহার করে তবে এইএস 128 বিট ব্লক আকার ব্যবহার করে। AES256 এ কীটি 256 বিট, তবে ব্লকের আকার নয়।

— ট্যানিন

এটিকে অন্য উপায়ে বলতে গেলে, "সেলফ.বস "গুলি সরানো এবং" AES. block_size "দ্বারা প্রতিস্থাপন করা উচিত

— অ্যালেক্সিস ২

চাবি হ্যাশ করছেন কেন? আপনি যদি আশা করেন যে এটি পাসওয়ার্ডের মতো কিছু, তবে আপনার SHA256 ব্যবহার করা উচিত নয়; পিবিকেডিএফ 2 এর মতো একটি কী ডেরিভেশন ফাংশন ব্যবহার করা আরও ভাল যা পাইক্রিপ্টো সরবরাহ করে।

— 20:44

@ ক্রিস - SHA256 একটি 32-বাইট হ্যাশ দেয় - AES256 এর জন্য একটি নিখুঁত আকারের কী। একটি কী তৈরির / উত্পন্নকরণটি এলোমেলো / সুরক্ষিত বলে ধরে নেওয়া হয় এবং এটি এনক্রিপশন / ডিক্রিপশন কোডের সুযোগের বাইরে থাকা উচিত - হ্যাশিং কেবল গ্যারান্টিযুক্ত যে কীটি নির্বাচিত সাইফারের সাথে ব্যবহারযোগ্য is

— zwer

_প্যাডে স্ব.বি.এস এ অ্যাক্সেস প্রয়োজন এবং _পেনডে দরকার নেই

— ননথিক

Answer 2

আপনার নিম্নলিখিত দুটি ফাংশন প্রয়োজন হতে পারে: pad- প্যাড করা (এনক্রিপশন করার সময়) এবং unpad- আনপড করা (ডিক্রিপশন করার সময়) যখন ইনপুটটির দৈর্ঘ্য BLOCK_SIZE এর একাধিক না হয়।

BS = 16
pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS) 
unpad = lambda s : s[:-ord(s[len(s)-1:])]

আপনি কি চাবি দৈর্ঘ্য জিজ্ঞাসা করছেন? আপনি সরাসরি কী ব্যবহার করার চেয়ে কীটির এমডি 5সাম ব্যবহার করতে পারেন।

আরও, পাইক্রিপ্টো ব্যবহারের আমার সামান্য অভিজ্ঞতা অনুসারে, ইনপুট একই হলে আইভিটি কোনও এনক্রিপশনের আউটপুট মিশ্রিত করতে ব্যবহৃত হয়, সুতরাং আইভিটি এলোমেলো স্ট্রিং হিসাবে বেছে নেওয়া হয় এবং এটি এনক্রিপশন আউটপুটটির অংশ হিসাবে ব্যবহার করা হয় এবং তারপরে বার্তাটি ডিক্রিপ্ট করতে এটি ব্যবহার করুন।

এবং এখানে আমার বাস্তবায়ন, আশা করি এটি আপনার পক্ষে কার্যকর হবে:

import base64
from Crypto.Cipher import AES
from Crypto import Random

class AESCipher:
    def __init__( self, key ):
        self.key = key

    def encrypt( self, raw ):
        raw = pad(raw)
        iv = Random.new().read( AES.block_size )
        cipher = AES.new( self.key, AES.MODE_CBC, iv )
        return base64.b64encode( iv + cipher.encrypt( raw ) ) 

    def decrypt( self, enc ):
        enc = base64.b64decode(enc)
        iv = enc[:16]
        cipher = AES.new(self.key, AES.MODE_CBC, iv )
        return unpad(cipher.decrypt( enc[16:] ))

Comments

আপনার যদি এমন কোনও ইনপুট থাকে যা হ'ল BLOCK_SIZE এর একাধিক? আমি মনে করি যে আনপ্যাড ফাংশনটি কিছুটা বিভ্রান্ত হবে ...

— Kjir

@ কেজির, তারপরে BLOCK_SIZE দৈর্ঘ্যের মান chr (BS) এর ক্রমটি মূল ডেটাতে যুক্ত হবে।

— মারকাস

@ মার্কাস padফাংশনটি নষ্ট হয়ে গেছে (কমপক্ষে পাই 3 এ), s[:-ord(s[len(s)-1:])]সংস্করণে কাজ করার জন্য এটি প্রতিস্থাপন করুন ।

— 11

@Torxed প্যাড ফাংশন pycryptodome (pycrypto ফলোআপ) সঙ্গে CryptoUtil.Padding.pad () মধ্যে উপকার হয়

— Comte

প্যাডিং চর হিসাবে কেবল একটি চরিত্রের ধ্রুবক কেন না?

— ইনাইমাথি

Answer 3

আমাকে "মোডগুলি" সম্পর্কে আপনার প্রশ্নের সমাধান করতে দিন। AES256 হ'ল এক ধরণের ব্লক সাইফার । এটি ইনপুট হিসাবে একটি 32-বাইট কী এবং 16-বাইট স্ট্রিং নেয় যা ব্লক বলে এবং একটি ব্লক আউটপুট করে। এনক্রিপ্ট করার জন্য আমরা একটি অপারেশন মোডে AES ব্যবহার করি । উপরের সমাধানগুলি সিবিসি ব্যবহারের পরামর্শ দেয় যা এর একটি উদাহরণ। অন্যটিকে সিটিআর বলা হয় এবং এটি ব্যবহার করা কিছুটা সহজ:

from Crypto.Cipher import AES
from Crypto.Util import Counter
from Crypto import Random

# AES supports multiple key sizes: 16 (AES128), 24 (AES192), or 32 (AES256).
key_bytes = 32

# Takes as input a 32-byte key and an arbitrary-length plaintext and returns a
# pair (iv, ciphtertext). "iv" stands for initialization vector.
def encrypt(key, plaintext):
    assert len(key) == key_bytes

    # Choose a random, 16-byte IV.
    iv = Random.new().read(AES.block_size)

    # Convert the IV to a Python integer.
    iv_int = int(binascii.hexlify(iv), 16) 

    # Create a new Counter object with IV = iv_int.
    ctr = Counter.new(AES.block_size * 8, initial_value=iv_int)

    # Create AES-CTR cipher.
    aes = AES.new(key, AES.MODE_CTR, counter=ctr)

    # Encrypt and return IV and ciphertext.
    ciphertext = aes.encrypt(plaintext)
    return (iv, ciphertext)

# Takes as input a 32-byte key, a 16-byte IV, and a ciphertext, and outputs the
# corresponding plaintext.
def decrypt(key, iv, ciphertext):
    assert len(key) == key_bytes

    # Initialize counter for decryption. iv should be the same as the output of
    # encrypt().
    iv_int = int(iv.encode('hex'), 16) 
    ctr = Counter.new(AES.block_size * 8, initial_value=iv_int)

    # Create AES-CTR cipher.
    aes = AES.new(key, AES.MODE_CTR, counter=ctr)

    # Decrypt and return the plaintext.
    plaintext = aes.decrypt(ciphertext)
    return plaintext

(iv, ciphertext) = encrypt(key, 'hella')
print decrypt(key, iv, ciphertext)

এটি প্রায়শই AES-CTR হিসাবে পরিচিত। আমি পাইক্রিপ্টোর সাথে এইএস-সিবিসি ব্যবহারে সতর্কতার পরামর্শ দেব । কারণটি হ'ল এটি আপনাকে প্যাডিং স্কিমটি নির্দিষ্ট করা প্রয়োজন , যেমন অন্যান্য প্রদত্ত সমাধানগুলির দ্বারা উদাহরণ হিসাবে। সাধারণভাবে, আপনি যদি প্যাডিং সম্পর্কে খুব সতর্ক না হন তবে এমন আক্রমণ রয়েছে যা সম্পূর্ণরূপে এনক্রিপশন ভেঙে দেয়!

এখন, এটি লক্ষ্য করা গুরুত্বপূর্ণ যে কীটি অবশ্যই একটি এলোমেলো, 32-বাইট স্ট্রিং ; একটি পাসওয়ার্ড যথেষ্ট না । সাধারণত, কীটি এর মতো তৈরি হয়:

# Nominal way to generate a fresh key. This calls the system's random number
# generator (RNG).
key1 = Random.new().read(key_bytes)

একটি কী পাসওয়ার্ড থেকেও নেওয়া যেতে পারে :

# It's also possible to derive a key from a password, but it's important that
# the password have high entropy, meaning difficult to predict.
password = "This is a rather weak password."

# For added # security, we add a "salt", which increases the entropy.
#
# In this example, we use the same RNG to produce the salt that we used to
# produce key1.
salt_bytes = 8 
salt = Random.new().read(salt_bytes)

# Stands for "Password-based key derivation function 2"
key2 = PBKDF2(password, salt, key_bytes)

উপরোক্ত কিছু সমাধান কী উপার্জনের জন্য SHA256 ব্যবহার করার পরামর্শ দেয় তবে এটি সাধারণত খারাপ ক্রিপ্টোগ্রাফিক অনুশীলন হিসাবে বিবেচিত হয় । পরীক্ষা করে দেখুন উইকিপিডিয়া অপারেশন মোড সম্পর্কে আরো জানার জন্য।

Comments

iv_int = int (binascii.hexlify (iv), 16) কাজ করে না, iv_int = int (binascii.hexlify (iv), 16) এর সাথে 'আমদানি বিন্যাসিআই' যুক্ত করুন এবং এটি (পাইথন 3.x এ) কাজ করা উচিত ), অন্যথায় দুর্দান্ত কাজ!

— ভালমন্ড

নোট করুন যে AESHINCATED এনক্রিপশন মোডগুলি AES-GCM হিসাবে ব্যবহার করা ভাল। জিসিএম অভ্যন্তরীণভাবে সিটিআর মোড ব্যবহার করে।

— কেলালাকা

এই কোডটির কারণে "TypeError: অবজেক্ট টাইপ <ক্লাস 'str'> সি কোডে পাস করা যায় না"

— ডা ওুন জং

Answer 4

যে কারও জন্য urlsfe_b64encode এবং urlsfe_b64decode ব্যবহার করতে চান, তাদের জন্য এখানে এমন সংস্করণ রয়েছে যা আমার জন্য কাজ করছে (ইউনিকোড ইস্যুতে কিছু সময় কাটিয়ে)

BS = 16
key = hashlib.md5(settings.SECRET_KEY).hexdigest()[:BS]
pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS)
unpad = lambda s : s[:-ord(s[len(s)-1:])]

class AESCipher:
    def __init__(self, key):
        self.key = key

    def encrypt(self, raw):
        raw = pad(raw)
        iv = Random.new().read(AES.block_size)
        cipher = AES.new(self.key, AES.MODE_CBC, iv)
        return base64.urlsafe_b64encode(iv + cipher.encrypt(raw)) 

    def decrypt(self, enc):
        enc = base64.urlsafe_b64decode(enc.encode('utf-8'))
        iv = enc[:BS]
        cipher = AES.new(self.key, AES.MODE_CBC, iv)
        return unpad(cipher.decrypt(enc[BS:]))

Answer 5

আপনি একটি ক্রিপ্টোগ্রাফিক হ্যাশ ফাংশন (ব্যবহার করে একটি অবাধ পাসওয়ার্ড বাইরে একটি পাসফ্রেজ পেতে পারেন না পাইথন এর builtin hashরয়েছে SHA-1 অথবা SHA-256 মতো)। পাইথন তার স্ট্যান্ডার্ড লাইব্রেরিতে উভয়ের জন্য সমর্থন অন্তর্ভুক্ত করে:

import hashlib

hashlib.sha1("this is my awesome password").digest() # => a 20 byte string
hashlib.sha256("another awesome password").digest() # => a 32 byte string

আপনি শুধু ব্যবহার করে একটি ক্রিপ্টোগ্রাফিক হ্যাশ মান অগ্রভাগ ছাঁটিয়া করতে [:16]বা [:24]তা দৈর্ঘ্য আপনাকে তা নির্দিষ্ট করার এর নিরাপত্তা আপ বজায় থাকবে।

Comments

পাসওয়ার্ড থেকে একটি কী তৈরি করার জন্য আপনাকে একটি SHA- পরিবারের হ্যাশ ফাংশন ব্যবহার করা উচিত নয় - এই বিষয়ে কোডা হালের রচনা দেখুন । পরিবর্তে স্ক্রিপ্টের মতো একটি আসল কী ডেরাইভেশন ফাংশন ব্যবহার করার বিষয়টি বিবেচনা করুন । (কোদা হালের রচনাটি স্ক্রিপ্টের প্রকাশের আগে লেখা হয়েছিল)

— বেঞ্জামিন বারেনব্লাত

ভবিষ্যতের পাঠকদের জন্য, আপনি যদি একটি পাসফ্রেজ থেকে কোনও কী বের করতে চাইছেন তবে পিবিকেডিএফ 2 সন্ধান করুন। পাইথনে এটি ব্যবহার করা মোটামুটি সহজ ( pypi.python.org/pypi/pbkdf2 )। আপনি যদি হ্যাশ পাসওয়ার্ড খুঁজছেন, তবে, বিসিআরপিট একটি ভাল বিকল্প।

— সি ফেয়ারওয়েদার

Answer 6

অন্যান্য উত্তরগুলির জন্য কৃতজ্ঞ যা অনুপ্রেরণা জোগায় কিন্তু আমার পক্ষে কার্যকর হয়নি।

এটি কীভাবে কাজ করে তা বোঝার জন্য কয়েক ঘন্টা ব্যয় করার পরে, আমি নীচে বাস্তব পাইক্রিপ্টোডোমেক্স গ্রন্থাগারটি নিয়ে এসেছি (এটি একটি অন্য গল্প যা আমি কীভাবে এটি একটি প্রকুয়ার পিছনে, উইন্ডোজে, একটি ভার্চুয়ালেনভে সেট করতে পেরেছি)

কাজ করছেন। আপনার বাস্তবায়ন, প্যাডিং, এনকোডিং, এনক্রিপ্টিং পদক্ষেপগুলি (এবং বিপরীতে) লিখতে ভুলবেন না। অর্ডারটি মাথায় রেখে আপনাকে প্যাক করতে হবে এবং আনপ্যাক করতে হবে।

আমদানি বেস 64
আমদানি হ্যাশলিব
ক্রিপ্টোডোম থেকে.সিফার আমদানি করুন এইএস
ক্রিপ্টোডোম থেকে and র্যান্ডম আমদানি get_random_bytes

__key__ = hashlib.sha256 (বি'16-অক্ষর কী ') di ডাইজেস্ট ()

ডিএফ এনক্রিপ্ট (কাঁচা):
    BS = AES. block_size
    প্যাড = ল্যাম্বদা এস: এস + (বিএস - লেন (গুলি)% বিএস) * সিআর (বিএস - লেন (গুলি)% বিএস)

    কাঁচা = বেস64.b64encode (প্যাড (কাঁচা)। এনকোড ('utf8'))
    iv = get_random_bytes (AES. block_size)
    সাইফার = এইএস.নিউ (কী = __কি__, মোড = AES.MODE_CFB, আইভ = আইভ)
    বেস 64.b64encode (iv + cipher.encrypt (কাঁচা)) ফিরুন

ডিফ ডিক্রিপ্ট (এনক্রিপ্ট):
    আনপ্যাড = ল্যাম্বদা এস: এস [: - অর্ড (গুলি [-1:])]

    enc = base64.b64decode (enc)
    iv = enc [: AES. block_size]
    সিফার = AES. নতুন (__ কী__, AES.MODE_CFB, iv)
    আনপ্যাড ফেরান (বেস64.b64decode (cipher.decrypt (enc [AES. block_size:]))। ডিকোড ('utf8'))

Comments

পাইক্রিপডোডোমেক্স ল্যাবসের সাহায্যে এর কার্যকরী উদাহরণের জন্য ধন্যবাদ জানাই। এটি বেশ সহায়ক!

— ইগ্র্রামুল

Answer 7

অন্যের সুবিধার জন্য, এখানে আমার ডিক্রিপশন বাস্তবায়ন যা আমি @ ক্রিল এবং @ মারকাসের উত্তরগুলি একত্রিত করে পেয়েছি। এটি ধরে নেওয়া হয় যে এটি এনক্রিপ্টডটেক্সট উদ্ধৃত এবং বেস 64 এনকোডযুক্ত HTTP অনুরোধের মাধ্যমে আসবে।

import base64
import urllib2
from Crypto.Cipher import AES


def decrypt(quotedEncodedEncrypted):
    key = 'SecretKey'

    encodedEncrypted = urllib2.unquote(quotedEncodedEncrypted)

    cipher = AES.new(key)
    decrypted = cipher.decrypt(base64.b64decode(encodedEncrypted))[:16]

    for i in range(1, len(base64.b64decode(encodedEncrypted))/16):
        cipher = AES.new(key, AES.MODE_CBC, base64.b64decode(encodedEncrypted)[(i-1)*16:i*16])
        decrypted += cipher.decrypt(base64.b64decode(encodedEncrypted)[i*16:])[:16]

    return decrypted.strip()

Answer 8

এটির উপর অন্যটি নিন (উপরের সমাধানগুলি থেকে ভারী উত্পন্ন) তবে

• প্যাডিংয়ের জন্য নাল ব্যবহার করে
• ল্যাম্বদা ব্যবহার করে না (কখনও ভক্ত ছিল না)

• পাইথন ২.7 এবং ৩.6.৫ দিয়ে পরীক্ষা করা হয়েছে

  #!/usr/bin/python2.7
  # you'll have to adjust for your setup, e.g., #!/usr/bin/python3
  
  
  import base64, re
  from Crypto.Cipher import AES
  from Crypto import Random
  from django.conf import settings
  
  class AESCipher:
      """
        Usage:
        aes = AESCipher( settings.SECRET_KEY[:16], 32)
        encryp_msg = aes.encrypt( 'ppppppppppppppppppppppppppppppppppppppppppppppppppppppp' )
        msg = aes.decrypt( encryp_msg )
        print("'{}'".format(msg))
      """
      def __init__(self, key, blk_sz):
          self.key = key
          self.blk_sz = blk_sz
  
      def encrypt( self, raw ):
          if raw is None or len(raw) == 0:
              raise NameError("No value given to encrypt")
          raw = raw + '\0' * (self.blk_sz - len(raw) % self.blk_sz)
          raw = raw.encode('utf-8')
          iv = Random.new().read( AES.block_size )
          cipher = AES.new( self.key.encode('utf-8'), AES.MODE_CBC, iv )
          return base64.b64encode( iv + cipher.encrypt( raw ) ).decode('utf-8')
  
      def decrypt( self, enc ):
          if enc is None or len(enc) == 0:
              raise NameError("No value given to decrypt")
          enc = base64.b64decode(enc)
          iv = enc[:16]
          cipher = AES.new(self.key.encode('utf-8'), AES.MODE_CBC, iv )
          return re.sub(b'\x00*$', b'', cipher.decrypt( enc[16:])).decode('utf-8')

Comments

যদি ইনপুট বাইট [] এর পিছনে নাল থাকে তবে এটি কাজ করবে না কারণ ডিক্রিপ্ট () ফাংশনে আপনি আপনার প্যাডিং নালগুলি PLUS কোনও পেছনের নাল খাবেন।

— বাজ মোসচেটি

হ্যাঁ, আমি উপরে বর্ণিত হিসাবে, এই যুক্তি নাল দিয়ে প্যাড। আপনি যে আইটেমগুলি এনকোড / ডিকোড করতে চান তাতে যদি পিছনের

— নালগুলি

Answer 9

আমি উভয় Cryptoএবং PyCryptodomexগ্রন্থাগার ব্যবহার করেছি এবং এটি দ্রুত জ্বলছে ...

import base64
import hashlib
from Cryptodome.Cipher import AES as domeAES
from Cryptodome.Random import get_random_bytes
from Crypto import Random
from Crypto.Cipher import AES as cryptoAES

BLOCK_SIZE = AES.block_size

key = "my_secret_key".encode()
__key__ = hashlib.sha256(key).digest()
print(__key__)

def encrypt(raw):
    BS = cryptoAES.block_size
    pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS)
    raw = base64.b64encode(pad(raw).encode('utf8'))
    iv = get_random_bytes(cryptoAES.block_size)
    cipher = cryptoAES.new(key= __key__, mode= cryptoAES.MODE_CFB,iv= iv)
    a= base64.b64encode(iv + cipher.encrypt(raw))
    IV = Random.new().read(BLOCK_SIZE)
    aes = domeAES.new(__key__, domeAES.MODE_CFB, IV)
    b = base64.b64encode(IV + aes.encrypt(a))
    return b

def decrypt(enc):
    passphrase = __key__
    encrypted = base64.b64decode(enc)
    IV = encrypted[:BLOCK_SIZE]
    aes = domeAES.new(passphrase, domeAES.MODE_CFB, IV)
    enc = aes.decrypt(encrypted[BLOCK_SIZE:])
    unpad = lambda s: s[:-ord(s[-1:])]
    enc = base64.b64decode(enc)
    iv = enc[:cryptoAES.block_size]
    cipher = cryptoAES.new(__key__, cryptoAES.MODE_CFB, iv)
    b=  unpad(base64.b64decode(cipher.decrypt(enc[cryptoAES.block_size:])).decode('utf8'))
    return b

encrypted_data =encrypt("Hi Steven!!!!!")
print(encrypted_data)
print("=======")
decrypted_data = decrypt(encrypted_data)
print(decrypted_data)

Answer 10

কিছুটা দেরি হলেও আমি মনে করি এটি খুব সহায়ক হবে। পিকেসিএস # 7 প্যাডিং এর মতো ব্যবহারের স্কিম সম্পর্কে কেউ উল্লেখ করেনি। আপনি এটি পূর্ববর্তী ফাংশনগুলির পরিবর্তে প্যাড করতে (যখন এনক্রিপশন করবেন) এবং আনপ্যাড (কখন ডিক্রিপশন করবেন) ব্যবহার করতে পারেন i আমি নীচের পুরো উত্স কোড সরবরাহ করব।

import base64
import hashlib
from Crypto import Random
from Crypto.Cipher import AES
import pkcs7
class Encryption:

    def __init__(self):
        pass

    def Encrypt(self, PlainText, SecurePassword):
        pw_encode = SecurePassword.encode('utf-8')
        text_encode = PlainText.encode('utf-8')

        key = hashlib.sha256(pw_encode).digest()
        iv = Random.new().read(AES.block_size)

        cipher = AES.new(key, AES.MODE_CBC, iv)
        pad_text = pkcs7.encode(text_encode)
        msg = iv + cipher.encrypt(pad_text)

        EncodeMsg = base64.b64encode(msg)
        return EncodeMsg

    def Decrypt(self, Encrypted, SecurePassword):
        decodbase64 = base64.b64decode(Encrypted.decode("utf-8"))
        pw_encode = SecurePassword.decode('utf-8')

        iv = decodbase64[:AES.block_size]
        key = hashlib.sha256(pw_encode).digest()

        cipher = AES.new(key, AES.MODE_CBC, iv)
        msg = cipher.decrypt(decodbase64[AES.block_size:])
        pad_text = pkcs7.decode(msg)

        decryptedString = pad_text.decode('utf-8')
        return decryptedString

import StringIO
import binascii


def decode(text, k=16):
    nl = len(text)
    val = int(binascii.hexlify(text[-1]), 16)
    if val > k:
        raise ValueError('Input is not padded or padding is corrupt')

    l = nl - val
    return text[:l]


def encode(text, k=16):
    l = len(text)
    output = StringIO.StringIO()
    val = k - (l % k)
    for _ in xrange(val):
        output.write('%02x' % val)
    return text + binascii.unhexlify(output.getvalue())

Comments

আমি জানি না যে উত্তরটি কমে গেছে তবে কেন তা জানতে আগ্রহী হব। এই পদ্ধতিটি কি নিরাপদ নয়? একটি ব্যাখ্যা দুর্দান্ত হবে।

— সিরিল এন।

@CyrilN। এই উত্তরটি পরামর্শ দেয় যে SHA-256 এর একক অনুরোধের মাধ্যমে পাসওয়ার্ডটি হ্যাশ করা যথেষ্ট। এটা না। একটি বড় পুনরাবৃত্তি গণনা ব্যবহার করে আপনার পাসওয়ার্ড থেকে কী ডেরাইভেশনের জন্য সত্যই আপনার পিবিকেডিএফ 2 বা অনুরূপ ব্যবহার করা উচিত।

— আর্টজম বি।

বিস্তারিত আর্টজমবি বিয়ের জন্য আপনাকে ধন্যবাদ!

— সিরিল এন।

আমার 44 টি দৈর্ঘ্যের একটি কী এবং আইভির কী রয়েছে। আমি কিভাবে আপনার ফাংশন ব্যবহার করতে পারি !? আমি যে ইন্টারনেট পেয়েছি তার সমস্ত অ্যালগরিদমে আমার ভেক্টর কী

— mahshid.r

Answer 11

https://stackoverflow.com/a/21928790/11402877

সামঞ্জস্যপূর্ণ utf-8 এনকোডিং

def _pad(self, s):
    s = s.encode()
    res = s + (self.bs - len(s) % self.bs) * chr(self.bs - len(s) % self.bs).encode()
    return res

Answer 12

from Crypto import Random
from Crypto.Cipher import AES
import base64

BLOCK_SIZE=16
def trans(key):
     return md5.new(key).digest()

def encrypt(message, passphrase):
    passphrase = trans(passphrase)
    IV = Random.new().read(BLOCK_SIZE)
    aes = AES.new(passphrase, AES.MODE_CFB, IV)
    return base64.b64encode(IV + aes.encrypt(message))

def decrypt(encrypted, passphrase):
    passphrase = trans(passphrase)
    encrypted = base64.b64decode(encrypted)
    IV = encrypted[:BLOCK_SIZE]
    aes = AES.new(passphrase, AES.MODE_CFB, IV)
    return aes.decrypt(encrypted[BLOCK_SIZE:])

Comments

দয়া করে কেবল কোড সরবরাহ করবেন না তবে আপনি কী করছেন এবং এটি কেন ভাল / বিদ্যমান উত্তরের মধ্যে পার্থক্য কী তাও ব্যাখ্যা করুন।

— ফ্লোরিয়ান কোচ

Md5.new (কী) .ডিজাস্ট () কে md5 (কী) .ডিজস্ট () দ্বারা প্রতিস্থাপন করুন এবং এটি একটি কবজির মতো কাজ করে!

— একটি স্টেফানি