Duplicate from Omnibus/Fernet-Encryption-QR

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,13 @@
+---
+title: Fernet Encryption
+emoji: 📊
+colorFrom: pink
+colorTo: green
+sdk: gradio
+sdk_version: 3.42.0
+app_file: app.py
+pinned: false
+duplicated_from: Omnibus/Fernet-Encryption-QR
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,232 @@
+import gradio as gr
+from cryptography.fernet import Fernet
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+import os
+import base64
+import hashlib
+from pathlib import Path
+import qr
+import stegan
+
+def create_key(passw):
+    key = passw.encode()
+    h = hashlib.new('sha256')
+    h.update(key)
+    key = h.hexdigest()
+    key = key.encode()
+    #salt = os.urandom(16)
+    salt = key
+    kdf = PBKDF2HMAC(
+        algorithm=hashes.SHA256(),
+        length=32,
+        salt=salt,
+        iterations=480000,
+    )
+    key = base64.urlsafe_b64encode(kdf.derive(key))
+    return key
+
+
+def encrypt(passw,mes=None,img=None,doc=None):
+    #key = Fernet.generate_key()
+    key = create_key(passw)
+    fernet = Fernet(key)
+    enc_mes=None
+    enc_file=None
+    if mes != None and mes != "":
+        bytes_m = mes.encode()
+        enc_mes = fernet.encrypt(bytes_m)
+        enc_mes = f'{enc_mes}+aaa+'
+    if img != None:
+        with open(f'{img}', "rb") as image_file:
+            bytes_i = base64.b64encode(image_file.read()) 
+        if mes != None and mes != "":
+            im_bytes = fernet.encrypt(bytes_i)
+            enc_mes = f'{enc_mes}{im_bytes}+bbb+'
+        else:
+            im_bytes = fernet.encrypt(bytes_i)
+            enc_mes = f'{im_bytes}+bbb+'
+            
+    #enc_qr = qr.make_qr(txt=(enc_mes.strip('"')))
+    qr_link = "https://omnibus-fernet-encryption-qr.hf.space"
+    enc_qr = stegan.conv_im(qr_link=qr_link,data=enc_mes)
+    if doc != None:
+        
+        print(dir(doc))
+        print(doc.name)
+        #print(doc.file)
+        doc_name = doc.name
+        doc_name = doc_name.split("/",4)[4]
+        #bytes_d = doc.encode()
+        
+        #doc = Path(doc)
+        with open(doc.name, "rb") as file:
+            # read all file data
+            file_data = file.read()
+        enc_doc = fernet.encrypt(file_data)
+        og_name = doc.name
+        og_end = og_name.split(".",1)[1]
+        og_front=og_name.split(".",1)[0]
+        
+        
+        enc_file=f'{doc.name}.ocrpt'
+        with open(enc_file, "wb") as file:
+            file.write(enc_doc)
+    
+    return enc_mes,enc_file,enc_qr
+    
+def decrypt(passw,enc_in=None):
+    key = create_key(passw)
+    fernet = Fernet(key)
+    dec_im = None
+    mes_dec= None
+    enc_in=enc_in.strip('"')
+    print (f'enc_in :::: {enc_in}')
+    
+    if "+aaa+" in enc_in:
+        mes1=enc_in.split("+aaa+",1)[0]
+        mes1=mes1.strip("b'").strip("'")
+        mes_bytes = bytes(mes1,'utf-8')
+        mes_dec = fernet.decrypt(mes_bytes).decode()
+        if "+bbb+" in enc_in:
+            mes12=enc_in.split("+aaa+",1)[1]
+            mes2=mes12.split("+bbb+",1)[0]
+            mes2=mes2.strip("b'").strip("'")
+            im_bytes = bytes(mes2,'utf-8')
+            print(f'im_bytes::{im_bytes}')
+            
+            mes2 = fernet.decrypt(mes2).decode()
+            #base = bytes(decMessage, 'utf-8')
+            with open(f"finished_im.png", "wb") as fh:
+                #fh.write(base64.decodebytes(im_bytes))
+                fh.write(base64.decodebytes(bytes(mes2, 'utf-8')))
+            fh.close     
+            dec_im = "finished_im.png"        
+   
+    if not "+aaa+" in enc_in:
+        if "+bbb+" in enc_in:
+            mes2 = enc_in.split("+bbb+",1)[0]
+            mes2=mes2.strip("b'").strip("'")
+            im_bytes = bytes(mes2,'utf-8')
+            print(f'im_bytes2::{im_bytes}')
+            mes2 = fernet.decrypt(mes2).decode()
+
+            #base = bytes(decMessage, 'utf-8')
+            with open(f"finished_im.png", "wb") as fh:
+                #fh.write(base64.decodebytes(im_bytes))
+                fh.write(base64.decodebytes(bytes(mes2, 'utf-8')))
+            fh.close     
+            dec_im = "finished_im.png"
+    return(dec_im,mes_dec)
+
+def decode_doc(passw,doc=None):
+    key = create_key(passw)
+    fernet = Fernet(key)
+    doc_name = doc.name
+    doc_name = doc_name.split("/",4)[4]
+    #bytes_d = doc.encode()
+    
+    #doc = Path(doc)
+    with open(doc.name, "rb") as file:
+        # read all file data
+        file_data = file.read()
+    dec_doc = fernet.decrypt(file_data)
+    og_name = doc.name
+    og_end = og_name.split(".",1)[1]
+    og_front=og_name.split(".",1)[0]
+    
+    dec_file = doc.name.strip(".ocrpt")
+    #enc_file=f'{doc.name}.ocrpt'
+    with open(dec_file, "wb") as file:
+        file.write(dec_doc)    
+    return dec_file
+
+def decode_qr(im,passw):
+    with open(f'{im}', "rb") as image_file:
+        bytes_i = base64.b64encode(image_file.read())     
+    decode_qr = stegan.decode(im)
+    dec_im = decrypt(passw, enc_in=decode_qr)
+    '''
+    print(f'decoded QR::{decode_qr}')
+    key = create_key(passw)
+    fernet = Fernet(key)
+    dec_im = None
+    mes_dec= None
+    enc_in=decode_qr.strip('"')
+    print (f'enc_in :::: {enc_in}')
+    
+    if "+aaa+" in enc_in:
+        mes1=enc_in.split("+aaa+",1)[0]
+        mes1=mes1.strip("b'").strip("'")
+        mes_bytes = bytes(mes1,'utf-8')
+        mes_dec = fernet.decrypt(mes_bytes).decode()
+        if "+bbb+" in enc_in:
+            mes12=enc_in.split("+aaa+",1)[1]
+            mes2=mes12.split("+bbb+",1)[0]
+            mes2=mes2.strip("b'").strip("'")
+            im_bytes = bytes(mes2,'utf-8')
+            print(f'im_bytes::{im_bytes}')
+            
+            mes2 = fernet.decrypt(mes2).decode()
+            #base = bytes(decMessage, 'utf-8')
+            with open(f"finished_im.png", "wb") as fh:
+                #fh.write(base64.decodebytes(im_bytes))
+                fh.write(base64.decodebytes(bytes(mes2, 'utf-8')))
+            fh.close     
+            dec_im = "finished_im.png"        
+   
+    if not "+aaa+" in enc_in:
+        if "+bbb+" in enc_in:
+            mes2 = enc_in.split("+bbb+",1)[0]
+            mes2=mes2.strip("b'").strip("'")
+            im_bytes = bytes(mes2,'utf-8')
+            print(f'im_bytes2::{im_bytes}')
+            mes2 = fernet.decrypt(mes2).decode()
+
+            #base = bytes(decMessage, 'utf-8')
+            with open(f"finished_im.png", "wb") as fh:
+                #fh.write(base64.decodebytes(im_bytes))
+                fh.write(base64.decodebytes(bytes(mes2, 'utf-8')))
+            fh.close     
+            dec_im = "finished_im.png"
+    '''
+    return(dec_im,mes_dec)
+    
+    
+with gr.Blocks() as app:
+    with gr.Tab("Encrypt"):
+        pass_in=gr.Textbox(label="Set Password")
+        with gr.Tab("String"):
+            mes = gr.Textbox(label = "Message")
+            with gr.Row():
+                im = gr.Image(type="filepath")
+        with gr.Tab("File"):
+            doc=gr.File()
+            enc_doc_out=gr.File()
+        en_btn = gr.Button("Encrypt")
+        enc_out = gr.Textbox(label="Encrypted Bytes")
+        enc_qr_out = gr.Image(label = "Encrypted QR")
+
+    with gr.Tab("Decrypt"):
+        pass_out = gr.Textbox(label="Enter Password")
+        with gr.Tab("String"):
+            enc_in = gr.Textbox(label="Encrypted Bytes")
+            d_btn = gr.Button("Decrypt")
+            d_txt = gr.Textbox(label="Decrypted")
+            d_im =gr.Image(label="Decrytped Image")
+        with gr.Tab("File"):
+            dec_doc_in = gr.File()
+            dec_doc_btn = gr.Button("Decrypt")
+            dec_doc_out=gr.File()
+        with gr.Tab("QR"):
+            dec_qr_im = gr.Image(type="filepath")
+            dec_qr_txt = gr.Textbox(label="Decrypted")
+            dec_qr_im_out =gr.Image(label="Decrytped Image")
+            dec_qr_btn = gr.Button("Decrypt")
+
+    dec_qr_btn.click(decode_qr,[dec_qr_im,pass_out],[dec_qr_im_out,dec_qr_txt])
+    dec_doc_btn.click(decode_doc,[pass_out,dec_doc_in],dec_doc_out)
+    en_btn.click(encrypt,[pass_in,mes,im,doc],[enc_out,enc_doc_out,enc_qr_out])
+    d_btn.click(decrypt,[pass_out,enc_in],[d_im,d_txt])
+app.launch()
+    

qr.py

@@ -0,0 +1,72 @@
+import gradio as gr
+import qrcode as qr
+import base64
+import cv2
+import os
+from PIL import Image
+
+def make_qr(txt=None,data=None,im_size=None):
+    if txt != None and txt != "" and data != None:
+        f = Image.open(f'{data}')
+        f.thumbnail((im_size,im_size))
+        f.save("tmp.jpg")
+        imr = open(f'tmp.jpg','rb')
+        out = f'{txt}+++{base64.b64encode(imr.read())}'
+        print (f'txt+data {out}')
+        img1 = qr.make(out,box_size=10,error_correction=qr.constants.ERROR_CORRECT_H)
+        img1.save("im.png")
+        return "im.png"
+    if txt == None or txt == "" and data != None:
+        f = Image.open(f'{data}')
+        f.thumbnail((im_size,im_size))
+        f.save("tmp1.jpg")
+        imr = open(f'tmp1.jpg','rb')
+        out = f'+++{base64.b64encode(imr.read())}'
+        print (f'data {out}')
+        img1 = qr.make(out,box_size=10,error_correction=qr.constants.ERROR_CORRECT_H)
+        img1.save("im1.png")
+        return "im1.png"
+        
+    if txt != None and txt != "" and data == None:
+        out = f'{txt}'
+        print (f'txt {out}')
+        img1 = qr.make(out,box_size=10,error_correction=qr.constants.ERROR_CORRECT_H)
+        img1.save("im2.png")
+        return "im2.png"    
+
+def cnt_im_bytes(im,txt_cnt,im_size):
+    f = Image.open(f'{im}')
+    f.thumbnail((im_size,im_size))
+    f.save("tmp11.jpg")
+    im_cnt=os.stat('tmp11.jpg').st_size
+    print(im_cnt)
+    tot_cnt=im_cnt+int(txt_cnt)
+    return im_cnt,tot_cnt  
+
+def cnt_bytes(txt,im_cnt):
+    txt_cnt = (len(txt.encode('utf-8')))
+    tot_cnt = txt_cnt + int(im_cnt)
+    return txt_cnt, tot_cnt
+
+
+def decode(im):
+    
+    image = cv2.imread(f'{im}')
+    qrCodeDetector = cv2.QRCodeDetector()
+    decodedText, points, _ = qrCodeDetector.detectAndDecode(image)
+    if points is not None:
+        text = decodedText
+    else:
+        text = "No QR Code Found"
+    return text
+def make_im(tx_str):
+    out = tx_str.split("+++b",1)[1]
+    out.replace("'","")
+    print(out)
+    decoded_data=base64.b64decode((out))
+    
+    #write the decoded data back to original format in  file
+    img_file = open('image.jpeg', 'wb')
+    img_file.write(decoded_data)
+    img_file.close()
+    return ('image.jpeg')

requirements.txt

@@ -0,0 +1,2 @@
+opencv-python
+qrcode

stegan.py

@@ -0,0 +1,115 @@
+import base64
+import gradio as gr
+import cv2
+import numpy as np
+import pandas as pd
+from PIL import Image
+import hashlib
+import os
+import uuid as uniq
+from qr import make_qr
+import math
+
+
+def to_bin(data):
+    """Convert `data` to binary format as string"""
+    if isinstance(data, str):
+        return ''.join([ format(ord(i), "08b") for i in data ])
+    elif isinstance(data, bytes):
+        return ''.join([ format(i, "08b") for i in data ])
+    elif isinstance(data, np.ndarray):
+        return [ format(i, "08b") for i in data ]
+    elif isinstance(data, int) or isinstance(data, np.uint8):
+        return format(data, "08b")
+    else:
+        raise TypeError("Type not supported.")
+def decode(image_name,txt=None):
+    BGRimage = cv2.imread(image_name)
+    image = cv2.cvtColor(BGRimage, cv2.COLOR_BGR2RGB)   
+    #resultd = hashlib.sha256(txt.encode('utf-8')).hexdigest()
+    binary_data = ""
+    for row in image:
+        for pixel in row:
+            r, g, b = to_bin(pixel)
+            binary_data += r[-1]
+            binary_data += g[-1]
+            binary_data += b[-1]
+    all_bytes = [ binary_data[i: i+8] for i in range(0, len(binary_data), 8) ]
+    decoded_data = ""
+    for byte in all_bytes:
+        decoded_data += chr(int(byte, 2))
+        if decoded_data[-5:] == "=====":
+            break
+    p = decoded_data[:-5].split("#",1)[1].split("#",1)[0]
+    #if p == resultd:
+    this = decoded_data[:-5].split("#",1)[0].split("'",1)[1]
+    #base = bytes(this, 'utf-8')
+    #with open(f"finished_im{uniqnum}.png", "wb") as fh:
+    #    fh.write(base64.decodebytes(bytes(this, 'utf-8')))
+    #fh.close
+    #return f"finished_im{uniqnum}.png"
+    return this
+
+def encode(image_name, secret_data,txt=None):
+    BGRimage = cv2.imread(image_name)
+    image = cv2.cvtColor(BGRimage, cv2.COLOR_BGR2RGB)    
+    n_bytes = image.shape[0] * image.shape[1] * 3 // 8
+    print("[*] Maximum bytes to encode:", n_bytes)
+    #resultp = hashlib.sha256(txt.encode('utf-8')).hexdigest() 
+    secret_data1=secret_data
+    #secret_data1=f'{secret_data}#{resultp}'
+    
+    while True:
+        if len(secret_data1) < (n_bytes):
+            secret_data1 = f'{secret_data1}#'
+        elif len(secret_data1) >= (n_bytes):
+            break    
+    secret_data = secret_data1    
+    if len(secret_data) > n_bytes:
+        return image_name, gr.Markdown.update("""<center><h3>Input image is too large""")
+    secret_data += "====="
+    data_index = 0
+    binary_secret_data = to_bin(secret_data)
+    data_len = len(binary_secret_data)
+    for row in image:
+        for pixel in row:
+            r, g, b = to_bin(pixel)
+            if data_index < data_len:
+                pixel[0] = int(r[:-1] + binary_secret_data[data_index], 2)
+                data_index += 1
+            if data_index < data_len:
+                pixel[1] = int(g[:-1] + binary_secret_data[data_index], 2)
+                data_index += 1
+            if data_index < data_len:
+                pixel[2] = int(b[:-1] + binary_secret_data[data_index], 2)
+                data_index += 1
+            if data_index >= data_len:
+                break
+    return image
+def conv_im(qr_link,data):
+    uniqnum = uniq.uuid4()
+
+    byte_size = len(data)
+    print (f'bytes:{byte_size}')
+    data_pixels = byte_size*4
+    print (f'pixels:{data_pixels}')
+    #data_sq=data_pixels/2
+    data_sq = int(math.sqrt(data_pixels))
+    data_pad = data_sq+100
+    print (f'square image:{data_pad}x{data_pad}')
+    
+    qr_im = make_qr(txt=qr_link)
+    img1 = Image.open(qr_im)
+    imgw = img1.size[0] 
+    imgh = img1.size[1]
+    print (f'qr Size:{img1.size}')
+    #img1.thumbnail((imgw*4,imgh*4), Image.Resampling.LANCZOS)
+    img1 = img1.resize((int(data_pad),int(data_pad)), Image.Resampling.LANCZOS)
+    print (img1.size)
+    img1.save(f'tmpim{uniqnum}.png')
+    
+    with open(f'tmpim{uniqnum}.png', "rb") as image_file:
+        encoded_string = base64.b64encode(image_file.read())
+        image_file.close()
+    im_out = encode(f'tmpim{uniqnum}.png',data)
+    return im_out