常见文件文件头和隐写术总结 CTF中Misc必备

#!/usr/bin/python

from struct import unpack
from binascii import hexlify, unhexlify
import sys, zlib

# Returns [Position, Chunk Size, Chunk Type, Chunk Data, Chunk CRC]
def getChunk(buf, pos):
    a = []
    a.append(pos)
    size = unpack('!I', buf[pos:pos+4])[0]
    # Chunk Size
    a.append(buf[pos:pos+4])
    # Chunk Type
    a.append(buf[pos+4:pos+8])
    # Chunk Data
    a.append(buf[pos+8:pos+8+size])
    # Chunk CRC
    a.append(buf[pos+8+size:pos+12+size])
    return a

def printChunk(buf, pos):
    print 'Pos : '+str(pos)+''
    print 'Type: ' + str(buf[pos+4:pos+8])
    size = unpack('!I', buf[pos:pos+4])[0]
    print 'Size: ' + str(size)
    #print 'Cont: ' + str(hexlify(buf[pos+8:pos+8+size]))
    print 'CRC : ' + str(hexlify(buf[pos+size+8:pos+size+12]).upper())
    print

if len(sys.argv)!=2:
    print 'Usage: ./this Stegano_PNG'
    sys.exit(2)

buf = open(sys.argv[1]).read()
pos=0

print "PNG Signature: " + str(unpack('cccccccc', buf[pos:pos+8]))
pos+=8

chunks = []
for i in range(3):
    chunks.append(getChunk(buf, pos))
    printChunk(buf, pos)
    pos+=unpack('!I',chunks[i][1])[0]+12


decompressed = zlib.decompress(chunks[1][3])
# Decompressed data length = height x (width * 3 + 1)
print "Data length in PNG file : ", len(chunks[1][3])
print "Decompressed data length: ", len(decompressed)

height = unpack('!I',(chunks[0][3][4:8]))[0]
width = unpack('!I',(chunks[0][3][:4]))[0]
blocksize = width * 3 + 1
filterbits = ''
for i in range(0,len(decompressed),blocksize):
    bit = unpack('2401c', decompressed[i:i+blocksize])[0]
    if bit == '\x00': filterbits+='0'
    elif bit == '\x01': filterbits+='1'
    else:
        print 'Bit is not 0 or 1... Default is 0 - MAGIC!'
        sys.exit(3)

s = filterbits
endianess_filterbits = [filterbits[i:i+8][::-1] for i in xrange(0, len(filterbits), 8)]

flag = ''
for x in endianess_filterbits:
    if x=='00000000': break
    flag += unhexlify('%x' % int('0b'+str(x), 2))

print 'Flag: ' + flag

from PIL import Image
import math
 
class LSB:
  def __init__(self):
    self.im=None
 
  def load_bmp(self,bmp_file):
    self.im=Image.open(bmp_file)
    self.w,self.h=self.im.size
    self.available_info_len=self.w*self.h # 不是绝对可靠的
    print ("Load>> 可嵌入",self.available_info_len,"bits的信息")
 
  def write(self,info):
    """先嵌入信息的长度，然后嵌入信息"""
    info=self._set_info_len(info)
    info_len=len(info)
    info_index=0
    im_index=0
    while True:
      if info_index>=info_len:
        break
      data=info[info_index]
      x,y=self._get_xy(im_index)
      self._write(x,y,data)
      info_index+=1
      im_index+=1
 
  def save(self,filename):
    self.im.save(filename)
 
  def read(self):
    """先读出信息的长度，然后读出信息"""
    _len,im_index=self._get_info_len()
    info=[]
    for i in range(im_index,im_index+_len):
      x,y=self._get_xy(i)
      data=self._read(x,y)
      info.append(data)
    return info
 
  #===============================================================#
  def _get_xy(self,l):
    return l%self.w,int(l/self.w)
 
  def _set_info_len(self,info):
    l=int(math.log(self.available_info_len,2))+1
    info_len=[0]*l
    _len=len(info)
    info_len[-len(bin(_len))+2:]=[int(i) for i in bin(_len)[2:]]
    return info_len+info
 
  def _get_info_len(self):
    l=int(math.log(self.w*self.h,2))+1
    len_list=[]
    for i in range(l):
      x,y=self._get_xy(i)
      _d=self._read(x,y)
      len_list.append(str(_d))
    _len=''.join(len_list)
    _len=int(_len,2)
    return _len,l
 
  def _write(self,x,y,data):
    origin=self.im.getpixel((x,y))
    lower_bit=origin%2
    if lower_bit==data:
      pass
    elif (lower_bit,data) == (0,1):
      self.im.putpixel((x,y),origin+1)
    elif (lower_bit,data) == (1,0):
      self.im.putpixel((x,y),origin-1)
 
  def _read(self,x,y):
    data=self.im.getpixel((x,y))
    return data%2
 
if __name__=="__main__":
  lsb=LSB()
  # 写
  lsb.load_bmp('test.bmp')
  info1=[0,1,0,1,1,0,1,0]
  lsb.write(info1)
  lsb.save('lsb.bmp')
  # 读
  lsb.load_bmp('lsb.bmp')
  info2=lsb.read()
  print (info2)

from PIL import Image

im = Image.open("extracted.bmp")
pix = im.load()
width, height = im.size

extracted_bits = []
for y in range(height):
    for x in range(width):
        r, g, b = pix[(x,y)]
        extracted_bits.append(r & 1)
        extracted_bits.append(g & 1)
        extracted_bits.append(b & 1)

extracted_byte_bits = [extracted_bits[i:i+8] for i in range(0, len(extracted_bits), 8)]
with open("extracted2.bmp", "wb") as out:
    for byte_bits in extracted_byte_bits:
                byte_str = ''.join(str(x) for x in byte_bits)
        byte = chr(int(byte_str, 2))
        out.write(byte)

import math
import cv2
import numpy as np
 
def dct(m):
    m = np.float32(m)/255.0
    return cv2.dct(m)*255

class Jsteg:
  def __init__(self):
    self.sequence_after_dct=None
 
  def set_sequence_after_dct(self,sequence_after_dct):
    self.sequence_after_dct=sequence_after_dct
    self.available_info_len=len([i for i in self.sequence_after_dct if i not in (-1,1,0)]) # 不是绝对可靠的
    print ("Load>> 可嵌入",self.available_info_len,'bits')
  
  def get_sequence_after_dct(self):
    return self.sequence_after_dct
 
  def write(self,info):
    """先嵌入信息的长度，然后嵌入信息"""
    info=self._set_info_len(info)
    info_len=len(info)
    info_index=0
    im_index=0
    while True:
      if info_index>=info_len:
        break
      data=info[info_index]
      if self._write(im_index,data):
        info_index+=1
      im_index+=1
 
 
  def read(self):
    """先读出信息的长度，然后读出信息"""
    _len,sequence_index=self._get_info_len()
    info=[]
    info_index=0
 
    while True:
      if info_index>=_len:
        break
      data=self._read(sequence_index)
      if data!=None:
        info.append(data)
        info_index+=1
      sequence_index+=1
 
    return info
 
  #===============================================================#
 
  def _set_info_len(self,info):
    l=int(math.log(self.available_info_len,2))+1
    info_len=[0]*l
    _len=len(info)
    info_len[-len(bin(_len))+2:]=[int(i) for i in bin(_len)[2:]]
    return info_len+info
 
  def _get_info_len(self):
    l=int(math.log(self.available_info_len,2))+1
    len_list=[]
    _l_index=0
    _seq_index=0
    while True:
      if _l_index>=l:
        break
      _d=self._read(_seq_index)
      if _d!=None:
        len_list.append(str(_d))
        _l_index+=1
      _seq_index+=1
    _len=''.join(len_list)
    _len=int(_len,2)
    return _len,_seq_index
 
  def _write(self,index,data):
    origin=self.sequence_after_dct[index]
    if origin in (-1,1,0):
      return False
 
    lower_bit=origin%2
    if lower_bit==data:
      pass
    elif origin>0:
      if (lower_bit,data) == (0,1):
        self.sequence_after_dct[index]=origin+1
      elif (lower_bit,data) == (1,0):
        self.sequence_after_dct[index]=origin-1
    elif origin<0:
      if (lower_bit,data) == (0,1):
        self.sequence_after_dct[index]=origin-1
      elif (lower_bit,data) == (1,0):
        self.sequence_after_dct[index]=origin+1
 
    return True
 
  def _read(self,index):
    if self.sequence_after_dct[index] not in (-1,1,0):
      return self.sequence_after_dct[index]%2
    else:
      return None
 
if __name__=="__main__":
  jsteg=Jsteg()
  # 写
  sequence_after_dct=[-1,0,1]*100+[i for i in range(-7,500)]
  jsteg.set_sequence_after_dct(sequence_after_dct)
  info1=[0,1,0,1,1,0,1,0]
  jsteg.write(info1)
  sequence_after_dct2=jsteg.get_sequence_after_dct()
  # 读
  jsteg.set_sequence_after_dct(sequence_after_dct2)
  info2=jsteg.read()
  print (info2)