def get_capacity(algorithm, filename, para):
"""This function gets parameters
algorithm ... the String naming the chosen algorithm
filename ... the chosen input filename
para ... a parameter for the chosen algorithm
and computes the capacity of the algorithm for the
given file and parameters.
It returns the capacity.
"""
if filename[-3:] == "gif":
palette_data = libstegofile.palette_data_t()
gif_struct = libstegofile.gif_internal_data_t()
bla = libstegofile.io_gif_read(filename, palette_data, gif_struct)
if algorithm == "Frirui":
cap = libstego.frirui_check_capacity(palette_data, para)
elif algorithm == "GifShuffle":
cap = libstego.gifshuffle_check_capacity(palette_data, para)
elif algorithm == "Sort / Unsort":
cap = libstego.sortunsort_check_capacity(palette_data, para)
libstegofile.io_gif_cleanup_data(palette_data)
# libstegofile.io_gif_cleanup_internal(gif_struct)
elif filename[-3:] == "png":
rgb_data = libstegofile.rgb_data_t()
rgb_internal = libstegofile.png_internal_data_t()
bla = libstegofile.io_png_read(filename, rgb_data, rgb_internal)
if algorithm == "Battlesteg":
cap = libstego.battlesteg_check_capacity(rgb_data, para)
elif algorithm == "CPT":
cap = libstego.cpt_check_capacity(rgb_data, para)
elif algorithm == "LSB":
bytes = libstego.new_charpp()
num_bytes = libstego.new_intp()
libstego.lsb_convert_png(rgb_data, bytes, num_bytes)
cap = libstego.lsb_check_capacity_indirect(
libstego.charpp_value(bytes), libstego.intp_value(num_bytes), para
)
libstego.lsb_cleanup_converted_data(libstego.charpp_value(bytes))
libstego.delete_charpp(bytes)
elif filename[-3:] == "wav":
wav_data = wav_data_t()
wav_int = wav_internal_data_t()
bla = libstegofile.io_wav_read(filename, wav_data, wav_int)
if algorithm == "Echo Hiding":
cap = libstego.echohiding_check_capacity(wav_data, para)
elif algorithm == "Phase Coding":
cap = libstego.phasecoding_check_capacity(wav_data, para)
elif algorithm == "PW":
cap = libstego.pw_check_capacity(wav_data, para)
elif filename[-3:] == "svg":
svg_data = libstegofile.svg_data_t()
svg_int = libstegofile.svg_internal_data_t()
bla = libstegofile.io_svg_read(filename, svg_data, svg_int)
if algorithm == "SVG Steg":
cap = libstego.svg_check_capacity(svg_data, para)
elif filename[-3:] in ["peg", "jpg"]:
jpeg_data = libstegofile.jpeg_data_t()
jpeg_int = libstegofile.jpeg_internal_data_t()
bla = libstegofile.io_jpeg_read(filename, jpeg_data, jpeg_int)
if algorithm == "F5":
cap = libstego.f5_check_capacity(jpeg_data, para)
elif algorithm == "MB2":
cap = libstego.mb2_check_capacity(jpeg_data, para)
elif algorithm == "PQ":
cap = libstego.pq_check_capacity(jpeg_data, para)
elif algorithm == "LSB":
cap = libstego.lsb_check_capacity(palette_data, para)
print cap
if cap[0] == 0:
return cap[1]
else:
print "Error computing capacity!"
return 666
def embed_or_extract_with_method(embed, method, filename, destfilename, message, msglen):
if embed:
print "embedding with method " + `method+1` + ", algo: " + method_to_algo[method]
else:
p_message = libstego.new_charp()
p_msglen = libstego.new_intp()
print "extracting with method " + `method+1` + ", algo: " + method_to_algo[method]
if method_to_algo[method] == "PQ":
# prepare data strucures
jpeg_data = libstegofile.jpeg_data_t()
stego_data = libstegofile.jpeg_data_t()
jpeg_int = libstegofile.jpeg_internal_data_t()
# read file data
err = libstegofile.io_jpeg_read(filename, jpeg_data, jpeg_int)
if err != 0:
# TODO better error handling
print "Error while reading JPG"
return
para = methods[method]
if embed:
err = libstego.pq_embed(jpeg_data, stego_data, message, len(message) + 1, para)
if err == 0:
err = libstegofile.io_jpeg_integrate(jpeg_int, stego_data)
if err != 0:
print "Error while integrating JPEG"
err = libstegofile.io_jpeg_write(destfilename, jpeg_int)
if err != 0:
print "Error while writing JPEG"
else:
print "An error occured while embedding with PQ."
else:
err = libstego.pq_extract(jpeg_data, p_message, p_msglen, para)
if err != 0:
print "An error occured while extracting with PQ."
# cleanup
libstegofile.io_jpeg_cleanup_data(jpeg_data)
libstegofile.io_jpeg_cleanup_data(stego_data)
libstegofile.io_jpeg_cleanup_internal_data(jpeg_int)
elif method_to_algo[method] == "F5":
# prepare data strucures
jpeg_data = libstegofile.jpeg_data_t()
stego_data = libstegofile.jpeg_data_t()
jpeg_int = libstegofile.jpeg_internal_data_t()
# read file data
err = libstegofile.io_jpeg_read(filename, jpeg_data, jpeg_int)
if err != 0:
# TODO better error handling
print "Error while reading JPG"
return
para = methods[method]
if embed:
err = libstego.f5_embed(jpeg_data, stego_data, message, len(message) + 1, para)
if err == 0:
err = libstegofile.io_jpeg_integrate(jpg_int, stego_data)
err = libstegofile.io_jpeg_write(destfilename, jpeg_int)
else:
print "Error while embedding with F5."
else:
err = libstego.f5_extract(jpeg_data, p_message, p_msglen, para)
if err != 0:
print "Error while extracting with F5."
# cleanup
libstegofile.jpeg_cleanup_data(jpeg_data)
libstegofile.io_jpeg_cleanup_data(stego_data)
libstegofile.io_jpeg_cleanup_internal_data(jpeg_int)
elif method_to_algo[method] == "Adv. Gifshuffle":
# prepare data strucures
palette_data = libstegofile.palette_data_t()
stego_data = libstegofile.palette_data_t()
gif_int = libstegofile.gif_internal_data_t()
# read file data
err = libstegofile.io_gif_read(filename, palette_data, gif_int)
if err != 0:
# TODO better error handling
print "Error while reading GIF"
return
para = methods[method]
if embed:
pw_message = para.password
pw_message_len = para.pwlen
para.password = ""
para.pwlen = 0
pwmsg_data = libstegofile.palette_data_t()
para.method = 0
err = libstego.gifshuffle_embed(palette_data, pwmsg_data, pw_message,
pw_message_len, para)
para.method = 1
err = libstego.gifshuffle_embed(pwmsg_data, stego_data,
message, msglen, para)
err = libstegofile.io_gif_integrate(gif_int, stego_data)
err = libstegofile.io_gif_write(destfilename, gif_int)
else:
pw_message = para.password
pw_message_len = para.pwlen
para.password = ""
para.pwlen = 0
pwmsg_data = libstegofile.palette_data_t()
para.method = 0
err = libstego.gifshuffle_embed(palette_data, pwmsg_data, pw_message,
pw_message_len, para)
para.adv_pal = pwmsg_data
para.method = 1
err = libstego.gifshuffle_extract(palette_data, p_message, p_msglen, para)
# cleanup
libstegofile.io_gif_cleanup_data(stego_data)
libstegofile.io_gif_cleanup_data(palette_data)
libstegofile.io_gif_cleanup_internal(gif_int)
elif method_to_algo[method] == "Gifshuffle":
# prepare data strucures
palette_data = libstegofile.palette_data_t()
stego_data = libstegofile.palette_data_t()
gif_int = libstegofile.gif_internal_data_t()
# read file data
err = libstegofile.io_gif_read(filename, palette_data, gif_int)
if err != 0:
# TODO better error handling
print "Error while reading GIF"
return
para = methods[method]
if embed:
err = libstego.gifshuffle_embed(palette_data, stego_data, message, msglen, para)
err = libstegofile.io_gif_integrate(gif_int, stego_data)
err = libstegofile.io_gif_write(destfilename, gif_int)
else:
err = libstego.gifshuffle_extract(palette_data, p_message, p_msglen, para)
# cleanup
libstegofile.io_gif_cleanup_data(stego_data)
libstegofile.io_gif_cleanup_data(palette_data)
libstegofile.io_gif_cleanup_internal(gif_int)
elif method_to_algo[method] == "Frirui":
# prepare data strucures
palette_data = libstegofile.palette_data_t()
stego_data = libstegofile.palette_data_t()
gif_int = libstegofile.gif_internal_data_t()
# read file data
err = libstegofile.io_gif_read(filename, palette_data, gif_int)
if err != 0:
# TODO better error handling
print "Error while reading GIF"
return
para = methods[method]
if embed:
err = libstego.frirui_embed(palette_data, stego_data, message, msglen, para)
err = libstegofile.io_gif_integrate(gif_int, stego_data)
err = libstegofile.io_gif_write(destfilename, gif_int)
else:
err = libstego.frirui_extract(palette_data, p_message, p_msglen, para)
# cleanup
libstegofile.io_gif_cleanup_data(stego_data)
libstegofile.io_gif_cleanup_data(palette_data)
libstegofile.io_gif_cleanup_internal(gif_int)
elif method_to_algo[method] == "Sort/Unsort":
# prepare data strucures
palette_data = libstegofile.palette_data_t()
stego_data = libstegofile.palette_data_t()
gif_int = libstegofile.gif_internal_data_t()
# read file data
err = libstegofile.io_gif_read(filename, palette_data, gif_int)
if err != 0:
# TODO better error handling
print "Error while reading GIF"
return
para = methods[method]
if embed:
libstego.sortunsort_embed(palette_data, stego_data, message, msglen, para)
err = libstegofile.io_gif_integrate(gif_int, stego_data)
err = libstegofile.io_gif_write(destfilename, gif_int)
else:
libstego.sortunsort_extract(palette_data, p_message, p_msglen, para)
# cleanup
libstegofile.io_gif_cleanup_data(stego_data)
libstegofile.io_gif_cleanup_data(palette_data)
libstegofile.io_gif_cleanup_internal(gif_int)
elif method_to_algo[method] == "CPT":
# prepare data strucures
rgb_data = libstegofile.rgb_data_t()
stego_data = libstegofile.rgb_data_t()
png_int = libstegofile.png_internal_data_t()
# read file data
err = libstegofile.io_png_read(filename, rgb_data, png_int)
if err != 0:
# TODO better error handling
print "Error while reading PNG"
return
para = methods[method]
if embed:
print(para.password)
print(para.pwlen)
print(para.block_width)
print(para.block_height)
err = libstego.cpt_embed(rgb_data, stego_data, message, msglen, para)
if err == 0:
err = libstegofile.io_png_integrate(png_int, stego_data)
err = libstegofile.io_png_write(destfilename, png_int)
else:
err = libstego.cpt_extract(rgb_data, p_message, p_msglen, para)
# cleanup
libstegofile.io_png_cleanup_data(rgb_data)
libstegofile.io_png_cleanup_data(stego_data)
libstegofile.io_png_cleanup_internal(png_int)
elif method_to_algo[method] == "Battlesteg":
# prepare data strucures
rgb_data = libstegofile.rgb_data_t()
stego_data = libstegofile.rgb_data_t()
png_int = libstegofile.png_internal_data_t()
# read file data
err = libstegofile.io_png_read(filename, rgb_data, png_int)
if err != 0:
# TODO better error handling
print "Error while reading PNG"
return
para = methods[method]
if embed:
err = libstego.battlesteg_embed(rgb_data, stego_data, message, msglen, para)
if err == 0:
err = libstegofile.io_png_integrate(png_int, stego_data)
err = libstegofile.io_png_write(destfilename, png_int)
else:
err = libstego.battlesteg_extract(rgb_data, p_message, p_msglen, para)
# cleanup
libstegofile.io_png_cleanup_data(rgb_data)
libstegofile.io_png_cleanup_data(stego_data)
libstegofile.io_png_cleanup_internal(png_int)
elif method_to_algo[method] == "SVG Steg":
# prepare data strucures
svg_data = libstegofile.svg_data_t()
svg_stego = libstegofile.svg_data_t()
svg_int = libstegofile.svg_internal_data_t()
# read file data
err = libstegofile.io_svg_read(filename, svg_data, svg_int)
if err != 0:
# TODO better error handling
print "Error while reading SVG"
return
para = methods[method]
if embed:
err = libstego.svg_embed(svg_data, stego_data, message, msglen, para)
if err == 0:
err = libstegofile.io_svg_integrate(svg_int, stego_data)
if err != 0:
print "Error while integrating SVG"
err = libstegofile.io_svg_write(destfilename, svg_int)
if err != 0:
print "Error while writing SVG"
else:
print "Error while embedding with SVG Stego"
else:
err = libstego.svg_extract(svg_data, p_message, p_msglen, para)
if err != 0:
print "Error while extracting with SVG Stego"
# cleanup
libstegofile.svg_cleanup_data(svg_data)
libstegofile.svg_cleanup_data(stego_data)
libstegofile.svg_cleanup_internal(svg_int)
elif method_to_algo[method] == "Echo Hiding":
# prepare data strucures
wav_data = libstegofile.wav_data_t()
stego_data = libstegofile.wav_data_t()
wav_int = libstegofile.wav_internal_data_t()
# read file data
err = libstegofile.io_wav_read(filename, wav_data, wav_int)
if err != 0:
# TODO better error handling
print "Error while reading WAV"
return
para = methods[method]
if embed:
err = libstego.eh_embed(wav_data, stego_data, message, msglen, para)
if err == 0:
err = libstegofile.io_wav_integrate(wav_int, stego_data)
if err != 0:
print "Error while integrating WAV"
err = libstegofile.io_wav_write(destfilename, wav_int)
if err != 0:
print "Error while writing WAV"
else:
print "Error while embedding with Echo Hiding"
else:
err = libstego.eh_extract(wav_data, p_message, p_msglen, para)
if err != 0:
print "Error while extracting with Echo Hiding"
# cleanup
libstegofile.wav_cleanup_data(wav_data)
libstegofile.wav_cleanup_data(stego_data)
libstegofile.wav_cleanup_internal(wav_int)
elif method_to_algo[method] == "Phase Coding":
# TODO implement
pass
elif method_to_algo[method] == "LSB":
# TODO implement
pass
if embed:
return None
else:
message = str(libstego.charp_value(p_message))
print message
msglen = libstego.intp_value(p_msglen)
return message
def embed_or_extract(algo, para, filename, destfilename):
#TODO: File read + Cleanup + implement for earch algo + parameter sets!
#TODO: Return (None) or Return Error
#TODO: After embed call function recursively to call extract (verify msg)
#TODO: Lots of "returns"
if filename.endswith("jpeg") or filename.endswith("jpg"):
src_data = libstegofile.jpeg_data_t()
jpg_int = libstegofile.jpeg_internal_data_t()
libstegofile.io_jpeg_read(filename, src_data, jpg_int)
if algo == "PQ":
if embed:
stego_data = libstegofile.jpeg_data_t()
err = libstego.pq_embed(src_data, stego_data, message, len(message) + 1, para)
if err == 0:
libstegofile.io_jpeg_integrate(jpg_int, stego_data)
libstegofile.io_jpeg_write(destfilename, jpg_int)
libstegofile.io_jpeg_cleanup_data(stego_data)
else:
err = libstego.pq_extract(src_data, message, msglen, para)
elif algo == "F5":
if embed:
stego_data = libstegofile.jpeg_data_t()
err = libstego.f5_embed(src_data, stego_data, message, len(message) + 1, para)
if err == 0:
libstegofile.io_jpeg_integrate(jpg_int, stego_data)
libstegofile.io_jpeg_write(destfilename, jpg_int)
libstegofile.io_jpeg_cleanup_data(stego_data)
else:
err = libstego.f5_extract(src_data, message, msglen, para)
"""elif algo == "LSB":
if embed:
stego_data = libstegofile.jpeg_data_t()
err = libstego.lsb_embed(src_data, stego_data, message, len(message) + 1, para)
if err == 0:
libstegofile.io_jpeg_integrate(jpg_int, stego_data)
libstegofile.io_jpeg_write(destfilename, jpg_int)
libstegofile.io_jpeg_cleanup_data(stego_data)
else:
err = libstego.lsb_extract(src_data, message, msglen, para)"""
libstegofile.io_jpeg_cleanup_data(src_data)
libstegofile.io_jpeg_cleanup_internal(jpg_int)
return err
elif filename.endswith("gif"):
src_data = libstegofile.palette_data_t()
stego_data = libstegofile.palette_data_t()
gif_int = libstegofile.gif_internal_data_t()
libstegofile.io_gif_read(filename, src_data, gif_int)
if algo == "Adv. Gifshuffle":
if embed:
pw_message = para.password
pw_message_len = para.pwlen
para.password = ""
para.pwlen = 0
pwmsg_data = libstegofile.palette_data_t()
para.method = 0
libstego.gifshuffle_embed(src_data, pwmsg_data, pw_message,
pw_message_len, para)
para.method = 1
libstego.gifshuffle_embed(pwmsg_data, stego_data,
message, msglen, para)
else:
pw_message = para.password
pw_message_len = para.pwlen
para.password = ""
para.pwlen = 0
pwmsg_data = libstegofile.palette_data_t()
para.method = 0
libstego.gifshuffle_embed(src_data, pwmsg_data, pw_message,
pw_message_len, para)
para.adv_pal = pwmsg_data
para.method = 1
libstego.gifshuffle_extract(src_data, message,
msglen, para)
elif algo == "Gifshuffle":
if embed:
libstego.gifshuffle_embed(src_data, stego_data, message,
msglen, para)
else:
libstego.gifshuffle_extract(src_data, message,
msglen, para)
elif algo == "Sort/Unsort":
if embed:
libstego.sortunsort_embed(src_data, stego_data, message,
msglen, para)
else:
libstego.sortunsort_extract(src_data, message,
msglen, para)
elif algo == "Frirui":
if embed:
libstego.frirui_embed(src_data, stego_data, message,
msglen, para)
else:
libstego.frirui_extract(src_data, message,
msglen, para)
elif algo == "LSB":
if embed:
#embed
pass
else:
#extract
pass
# Write back and clean up
libstegofile.io_gif_integrate(gif_int, stego_data)
libstegofile.io_gif_write(destfilename, gif_int)
libstegofile.io_gif_cleanup_data(stego_data)
libstegofile.io_gif_cleanup_data(src_data)
libstegofile.io_gif_cleanup_internal(gif_int)
elif filename.endswith("png"):
src_data, stego_data, png_int = call_file_read(libstegofile.rgb_data_t,
libstegofile.png_internal_data_t,
libstegofile.io_png_read)
if algo == "CPT":
call_embed_extract(embed, libstego.cpt_embed, libstego.cpt_extract,
src_data, stego_data, message, msglen, para)
elif algo == "Battlesteg":
call_embed_extract(embed, libstego.battlesteg_embed, libstego.battlesteg_extract,
src_data, stego_data, message, msglen, para)
elif algo == "LSB":
call_embed_extract(embed, libstego.lsb_embed, libstego.lsb_extract,
src_data, stego_data, message, msglen, para)
libstegofile.io_png_integrate(png_int, stego_data)
libstegofile.io_png_write(destfilename, png_int)
libstegofile.io_png_cleanup_data(stego_data)
libstegofile.io_png_cleanup_data(src_data)
libstegofile.io_png_cleanup_internal(png_int)
elif filename.endswith("wav"):
if algo == "Echo Hiding":
if embed:
#embed
pass
else:
#extract
pass
elif algo == "Phase Coding":
if embed:
#embed
pass
else:
#extract
pass
elif algo == "LSB":
if embed:
#embed
pass
else:
#extract
pass
elif filename.endswith("svg"):
if algo == "SVG Steg":
if embed:
#embed
pass
else:
#extract
pass
elif algo == "LSB":
if embed:
#embed
pass
else:
#extract
pass
def get_best_method(filename, msglen):
global num_methods
global method_to_algo
global methods
for method in range(0, num_methods):
fits = False
para = methods[method]
print "Testing method " + `method+1`
print "Algorithm: " + method_to_algo[method]
if method_to_algo[method] == "PQ":
# prepare data strucures
jpeg_data = libstegofile.jpeg_data_t()
jpeg_int = libstegofile.jpeg_internal_data_t()
# read file data
err = libstegofile.io_jpeg_read(filename, jpeg_data, jpeg_int)
if err != 0:
# TODO better error handling -> detailed message what went wrong
# by using the 'lstg_errno' code
return None
# check if message fits with the current params
if libstego.pq_check_capacity(jpeg_data, para) >= msglen:
fits = True
# cleanup
libstegofile.io_jpeg_cleanup_data(jpeg_data)
libstegofile.io_jpeg_cleanup_internal_data(jpeg_int)
elif method_to_algo[method] == "F5":
# prepare data strucures
jpeg_data = libstegofile.jpeg_data_t()
jpeg_int = libstegofile.jpeg_internal_data_t()
# read file data
err = libstegofile.io_jpeg_read(filename, jpeg_data, jpeg_int)
if err != 0:
# TODO better error handling -> detailed message what went wrong
# by using the 'lstg_errno' code
return None
# check if message fits with the current params
if libstego.f5_check_capacity(jpeg_data) >= msglen:
fits = True
# cleanup
libstegofile.io_jpeg_cleanup_data(jpeg_data)
libstegofile.io_jpeg_cleanup_internal_data(jpeg_int)
elif method_to_algo[method] in ["Adv. Gifshuffle", "Gifshuffle"]:
# prepare data strucures
palette_data = libstegofile.palette_data_t()
gif_int = libstegofile.gif_internal_data_t()
# read file data
err = libstegofile.io_gif_read(filename, palette_data, gif_int)
if err != 0:
# TODO better error handling -> detailed message what went wrong
# by using the 'lstg_errno' code
return None
# check if message fits with the current params
if libstego.gifshuffle_check_capacity(palette_data, para) >= msglen:
fits = True
# cleanup
libstegofile.io_gif_cleanup_data(palette_data)
libstegofile.io_gif_cleanup_internal(gif_int)
elif method_to_algo[method] == "Frirui":
# prepare data strucures
palette_data = libstegofile.palette_data_t()
gif_int = libstegofile.gif_internal_data_t()
# read file data
err = libstegofile.io_gif_read(filename, palette_data, gif_int)
if err != 0:
# TODO better error handling -> detailed message what went wrong
# by using the 'lstg_errno' code
return None
# check if message fits with the current params
if libstego.frirui_check_capacity(palette_data, para) >= msglen:
fits = True
# cleanup
libstegofile.io_gif_cleanup_data(palette_data)
libstegofile.io_gif_cleanup_internal(gif_int)
elif method_to_algo[method] == "Sort/Unsort":
# prepare data strucures
palette_data = libstegofile.palette_data_t()
gif_int = libstegofile.gif_internal_data_t()
# read file data
err = libstegofile.io_gif_read(filename, palette_data, gif_int)
if err != 0:
# TODO better error handling -> detailed message what went wrong
# by using the 'lstg_errno' code
return None
# check if message fits with the current params
if libstego.sortunsort_check_capacity(palette_data, para) >= msglen:
fits = True
# cleanup
libstegofile.io_gif_cleanup_data(palette_data)
libstegofile.io_gif_cleanup_internal(gif_int)
elif method_to_algo[method] == "CPT":
# prepare data strucures
rgb_data = libstegofile.rgb_data_t()
png_int = libstegofile.png_internal_data_t()
# read file data
err = libstegofile.io_png_read(filename, rgb_data, png_int)
if err != 0:
# TODO better error handling -> detailed message what went wrong
# by using the 'lstg_errno' code
return None
# check if message fits with the current params
if libstego.cpt_check_capacity(rgb_data, para) >= msglen:
fits = True
# cleanup
libstegofile.io_png_cleanup_data(rgb_data)
libstegofile.io_png_cleanup_internal(png_int)
elif method_to_algo[method] == "Battlesteg":
# prepare data strucures
rgb_data = libstegofile.rgb_data_t()
png_int = libstegofile.png_internal_data_t()
# read file data
err = libstegofile.io_png_read(filename, rgb_data, png_int)
if err != 0:
# TODO better error handling -> detailed message what went wrong
# by using the 'lstg_errno' code
return None
# check if message fits with the current params
if libstego.battlesteg_check_capacity(rgb_data, para) >= msglen:
fits = True
# cleanup
libstegofile.io_png_cleanup_data(rgb_data)
libstegofile.io_png_cleanup_internal(png_int)
elif method_to_algo[method] == "SVG Steg":
# prepare data strucures
svg_data = libstegofile.svg_data_t()
svg_int = libstegofile.svg_internal_data_t()
# read file data
err = libstegofile.io_svg_read(filename, svg_data, svg_int)
if err != 0:
# TODO better error handling -> detailed message what went wrong
# by using the 'lstg_errno' code
return None
# check if message fits with the current params
if libstego.svg_check_capacity(svg_data, para) >= msglen:
fits = True
# cleanup
libstegofile.io_svg_cleanup_data(svg_data)
libstegofile.io_svg_cleanup_internal(svg_int)
elif method_to_algo[method] == "Echo Hiding":
# prepare data strucures
wav_data = libstegofile.wav_data_t()
wav_int = libstegofile.wav_internal_data_t()
# read file data
err = libstegofile.io_wav_read(filename, wav_data, wav_int)
if err != 0:
# TODO better error handling -> detailed message what went wrong
# by using the 'lstg_errno' code
return None
# check if message fits with the current params
if libstego.eh_check_capacity(wav_data, para) >= msglen:
fits = True
# cleanup
libstegofile.io_wav_cleanup_data(wav_data)
libstegofile.io_wav_cleanup_internal(wav_int)
elif method_to_algo[method] == "Phase Coding":
# TODO implement
pass
elif method_to_algo[method] == "LSB":
# TODO implement
pass
if fits:
print "best method: " + `method+1`
return method
return None
def get_best_method(filename, filetype, msglen, password):
# setup all methods
setup_methods(password)
# get methods for current file type
num_selected, sel_method = get_methods_for_filetype(filetype)
for i in [0, num_selected-1]:
fits = False
if method_to_algo[i] == "PQ":
# prepare data strucures
jpeg_data = libstegofile.jpeg_data_t()
jpeg_int = libstegofile.jpeg_internal_data_t()
# read file data
err = libstegofile.io_jpeg_read(filename, jpeg_data, jpeg_int)
if err != 0:
# TODO better error handling -> detailed message what went wrong
# by using the 'lstg_errno' code
return None
# check if message fits with the current params
para = methods[i]
if libstego.pq_check_capacity(jpeg_data, para) >= msglen:
fits = True
# cleanup
libstegofile.jpeg_cleanup_data(jpeg_data)
libstegofile.io_jpeg_cleanup_internal(jpg_int)
if method_to_algo[i] == "F5":
# prepare data strucures
jpeg_data = libstegofile.jpeg_data_t()
jpeg_int = libstegofile.jpeg_internal_data_t()
# read file data
err = libstegofile.io_jpeg_read(filename, jpeg_data, jpeg_int)
if err != 0:
# TODO better error handling -> detailed message what went wrong
# by using the 'lstg_errno' code
return None
# check if message fits with the current params
para = methods[i]
if libstego.f5_check_capacity(jpeg_data, para) >= msglen:
fits = True
# cleanup
libstegofile.jpeg_cleanup_data(jpeg_data)
libstegofile.io_jpeg_cleanup_internal(jpg_int)
if method_to_algo[i] in ["Adv. Gifshuffle", "Gifshuffle"]:
# prepare data strucures
palette_data = libstegofile.palette_data_t()
gif_int = libstegofile.gif_internal_data_t()
# read file data
err = libstegofile.io_gif_read(filename, palette_data, gif_int)
if err != 0:
# TODO better error handling -> detailed message what went wrong
# by using the 'lstg_errno' code
return None
# check if message fits with the current params
para = methods[i]
if libstego.gifshuffle_check_capacity(palette_data, para) >= msglen:
fits = True
# cleanup
libstegofile.io_gif_cleanup_data(palette_data)
libstegofile.io_gif_cleanup_internal(gif_int)
if method_to_algo[i] == "Frirui":
# prepare data strucures
palette_data = libstegofile.palette_data_t()
gif_int = libstegofile.gif_internal_data_t()
# read file data
err = libstegofile.io_gif_read(filename, palette_data, gif_int)
if err != 0:
# TODO better error handling -> detailed message what went wrong
# by using the 'lstg_errno' code
return None
# check if message fits with the current params
para = methods[i]
if libstego.frirui_check_capacity(palette_data, para) >= msglen:
fits = True
# cleanup
libstegofile.io_gif_cleanup_data(palette_data)
libstegofile.io_gif_cleanup_internal(gif_int)
if method_to_algo[i] == "Sort/Unsort":
# prepare data strucures
palette_data = libstegofile.palette_data_t()
gif_int = libstegofile.gif_internal_data_t()
# read file data
err = libstegofile.io_gif_read(filename, palette_data, gif_int)
if err != 0:
# TODO better error handling -> detailed message what went wrong
# by using the 'lstg_errno' code
return None
# check if message fits with the current params
para = methods[i]
if libstego.sortunsort_check_capacity(palette_data, para) >= msglen:
fits = True
# cleanup
libstegofile.io_gif_cleanup_data(palette_data)
libstegofile.io_gif_cleanup_internal(gif_int)
if method_to_algo[i] == "CPT":
# prepare data strucures
rgb_data = libstegofile.rgb_data_t()
png_int = libstegofile.png_internal_data_t()
# read file data
err = libstegofile.io_png_read(filename, rgb_data, png_int)
if err != 0:
# TODO better error handling -> detailed message what went wrong
# by using the 'lstg_errno' code
return None
# check if message fits with the current params
para = methods[i]
if libstegofile.cpt_check_capacity(rgb_data, para) >= msglen:
fits = True
# cleanup
libstegofile.io_png_cleanup_data(rgb_data)
libstegofile.io_png_cleanup_internal(png_int)
if method_to_algo[i] == "Battlesteg":
# prepare data strucures
rgb_data = libstegofile.rgb_data_t()
png_int = libstegofile.png_internal_data_t()
# read file data
err = libstegofile.io_png_read(filename, rgb_data, png_int)
if err != 0:
# TODO better error handling -> detailed message what went wrong
# by using the 'lstg_errno' code
return None
# check if message fits with the current params
para = methods[i]
if libstegofile.battlesteg_check_capacity(rgb_data, para) >= msglen:
fits = True
# cleanup
libstegofile.io_png_cleanup_data(rgb_data)
libstegofile.io_png_cleanup_internal(png_int)
if method_to_algo[i] == "SVG Steg":
# prepare data strucures
svg_data = libstegofile.svg_data_t()
svg_int = libstegofile.svg_internal_data_t()
# read file data
err = libstegofile.io_svg_read(filename, svg_data, svg_int)
if err != 0:
# TODO better error handling -> detailed message what went wrong
# by using the 'lstg_errno' code
return None
# check if message fits with the current params
para = methods[i]
if libstego.svg_check_capacity(svg_data, para) >= msglen:
fits = True
# cleanup
libstegofile.svg_cleanup_data(svg_data)
libstegofile.svg_cleanup_internal(svg_int)
if method_to_algo[i] == "Echo Hiding":
# TODO implement
pass
if method_to_algo[i] == "Phase Coding":
# TODO implement
pass
if method_to_algo[i] == "LSB":
# TODO implement
pass
if fits:
return i
return None