{"id":17,"date":"2026-06-07T12:02:27","date_gmt":"2026-06-07T12:02:27","guid":{"rendered":"https:\/\/www.tim.alchamaa.com\/?page_id=17"},"modified":"2026-06-07T12:02:27","modified_gmt":"2026-06-07T12:02:27","slug":"exp","status":"publish","type":"page","link":"https:\/\/www.tim.alchamaa.com\/?page_id=17","title":{"rendered":"exp"},"content":{"rendered":"\n
    \n
  1. Introduction to JPEG-based Steganography
    Steganography is a data hiding technique that has been used in the applications of information
    protection. It transmits a secret message by hiding it into a cover object in order to create a
    hidden way of communication. Steganography has the same goal as cryptography since they aim
    to protect sensitive information. But they differ in the way of working; Cryptography converts the
    plain message into an unreadable encrypted message where the presence of the cryptography is
    not concealed, while steganography smuggles the message by embedding it into an innocentlooking
    object and thus creating an invisible communication channel.
    The techniques of steganography have been developed in the field of digital objects such as JPEG
    images, where we can make the JPEG image a container for a secret message by embedding the
    message Bits within it. The JPEG image will represent a hidden communication channel, where
    no one knows what it contains except the sender and intended receiver. Many JPEG-based
    steganographic methods have been invented in the DCT domain, including the F5 algorithm
    developed by Westfeld [1]. The F5 algorithm was born in 2001 and is still one of the more known
    methods.<\/li>\n\n\n\n
  2. F5 Steganographic Method
    Many of the DCT-based methods are based on the idea of a hash function. The function hashes a
    specific number (n) of quantized DCT coefficients (qDCT) to produce a specific number (k) of
    Bits. When the sender wants to embed a secret (k) Bits message, the (n) qDCT coefficients
    should be modified accordingly. Thus, when the receiver hashes the modified (n) qDCT
    coefficients, the hidden message is then obtained. The modifications are always constrained by
    requirements and rules depending on the considered algorithm.
    The F5 algorithm was proposed by Westfeld [1]. It is based on the idea of the matrix encoding
    (dmax, n, k) with dmax=1, where its goal is to minimize the number of changes made to the
    qDCT coefficients. The F5 algorithm takes (n) qDCT coefficients and hashes them to (k) Bits
    using a Xor-based hash function. When the sender needs a modification to embed the secret
    message, only one coefficient is changed since the resulting (n) qDCT coefficients should not
    have a hamming distance of more than dmax=1 from the original (n) qDCT coefficients. The (k)
    and (n) are calculated based on the original image capacity as well as the message length.<\/li>\n\n\n\n
  3. Matlab Implementation of F5 Algorithm
    3.1 Huffman Coding and Decoding
    The DCT-based steganographic methods are based on the idea of modifying the qDCT
    coefficients in such a way allowing to embed a stream of Bits. Thus, we need to have the ability
    to access the qDCT coefficients of a given JPEG file. The Matlab’s built-in functions used to
    handle digital images provide only basic conversion between the given JPEG file and image
    pixels. They don\u2019t give any access to the qDCT coefficients. In order to overcome this issue, we
    use a dedicated Matlab JPEG Toolbox developed by Sallee [2]. The used JPEG Toolbox contains
    special functions allowing to access and manipulate the qDCT coefficients of a given JPEG file.
    6
    The main two functions in the Sallee’s package \u201cjpeg_read\u201d and \u201cjpeg_write\u201d perform the steps
    of the lossless compression applied to the qDCT coefficients including Huffman coding and
    decoding. Thus, they provide more functionality, since they give the ability to gain direct access
    to all the structural elements of a JPEG file from Matlab, including the matrices of qDCT
    coefficients and the quantization tables.
    3.2 Implementation of F5 Embedding Process
    3.2.1 Steps of F5 Embedding Process
    In this section, we present a block diagram showing the implementation steps of the F5 algorithm
    on the sender side of the connection, where we hide the message file into a given JPEG image.
    At first, the \u201cjpeg_read\u201d function reads the given JPEG file and performs the entropy decoding.
    The \u201cjpeg_read\u201d function gives a Matlab structure containing the qDCT coefficients matrices,
    quantization tables, and other information. Only the qDCT coefficients matrix of Y component is
    used to embed the secret message because of its large size compared to those of the other two
    components.
    Before running the F5 embedding process, we should have two tasks completed:
    1- We define the matrix encoding ME by calculating the size of the message file and the
    number of Non-zero coefficients in the resulting Y matrix. The ME calculator gives the
    initial value of the matrix encoding that we should use in the embedding process.
    2- Typically, the embedding process should be protected and connected with a secret key.
    Thus, we should use a key-based permutation generator. The generated permutation is
    applied to the qDCT coefficients matrix of Y component before running the F5_ME
    embedding process.
    During the running of the F5 embedding process, we take into consideration the shrinkage of
    Non-zero qDCT coefficients, thus a shrinkage tester is always running. The tester aims to detect
    the occurrence of the shrinkage during the process, so the shrinking coefficient will be replaced
    by another one. In addition, the tester aims to ensure that the message file was embedded entirely
    according to the used ME, otherwise, the ME will be recalculated and the embedding process will
    be repeated according to the new ME.
    In the end, the resulting matrix is inversely permuted in order to get back the original order of the
    Y matrix of qDCT coefficients. The resulting qDCT coefficients matrix of Y component will then
    be in the same order as the original one, but<\/li>\n\n\n\n
  4. <\/li>\n<\/ol>\n\n\n\n

    Wassim Al Chamaa
    MATLAB Implementation of the
    Steganographic Algorithm F5
    Matlab Codes for F5 Algorithm
    Project Report
    Computer Science<\/p>\n\n\n\n

    Bibliographic information published by the German National Library:
    The German National Library lists this publication in the National Bibliography;
    detailed bibliographic data are available on the Internet at http:\/\/dnb.dnb.de .
    This book is copyright material and must not be copied, reproduced, transferred,
    distributed, leased, licensed or publicly performed or used in any way except as
    specifically permitted in writing by the publishers, as allowed under the terms and
    conditions under which it was purchased or as strictly permitted by applicable
    copyright law. Any unauthorized distribution or use of this text may be a direct
    infringement of the author s and publisher s rights and those responsible may be
    liable in law accordingly.
    Imprint:
    Copyright \u00a9 2018 GRIN Verlag
    ISBN: 9783668933439
    This book at GRIN:
    https:\/\/www.grin.com\/document\/464340
    Wassim Al Chamaa
    MATLAB Implementation of the Steganographic Algorithm
    F5
    Matlab Codes for F5 Algorithm
    GRIN Verlag
    GRIN – Your knowledge has value
    Since its foundation in 1998, GRIN has specialized in publishing academic texts by
    students, college teachers and other academics as e-book and printed book. The
    website www.grin.com is an ideal platform for presenting term papers, final papers,
    scientific essays, dissertations and specialist books.
    Visit us on the internet:
    http:\/\/www.grin.com\/
    http:\/\/www.facebook.com\/grincom
    http:\/\/www.twitter.com\/grin_com
    MATLAB Implementation of the Steganographic Algorithm F5
    By
    Wassim Al Chamaa
    2
    TABLE OF CONTENTS
    ABSTRACT
    LIST OF FIGURES<\/p>\n\n\n\n

      \n
    1. Introduction to JPEG-based Steganography<\/li>\n\n\n\n
    2. F5 Steganographic Method<\/li>\n\n\n\n
    3. Matlab Implementation of F5 Algorithm
      3.1 Huffman Coding and Decoding
      3.2 Implementation of F5 Embedding Process
      3.2.1 Steps of F5 Embedding Process
      3.2.2 Main Script and Called Functions
      3.2.3 Matlab Codes of F5 Embedding Process
      3.2.3.1 F5Embed Matlab Main Script
      3.2.3.2 Msgsize Matlab Function
      3.2.3.3 Qdct2Img Matlab Function
      3.2.3.4 MediCap Matlab Function
      3.2.3.5 MatEncod Matlab Function
      3.2.3.6 GetkBits Matlab Function
      3.2.3.7 DoEmbed Matlab Function
      3.2.3.8 DoStego Matlab Function
      3.2.3.9 F5Hash Matlab Function
      3.2.3.10 DoChange Matlab Function
      3.2.3.11 HistPlot Matlab Function
      3.3 Implementation of F5 Extracting Process
      3.3.1 Steps of F5 Extracting Process
      3.3.2 Main Script and Called Functions
      3.3.3 Matlab Codes of F5 Extracting Process
      3.3.3.1 F5Extract Matlab Main Script
      3.3.3.2 MediCap Matlab Function
      3.3.3.3 DoExtract Matlab Function
      3.3.3.4 F5Hash Matlab Function<\/li>\n\n\n\n
    4. Programming Notes
      References
      3
      ABSTRACT
      The F5 algorithm proposed by Westfeld is still one of the most known algorithms in the field of
      DCT-based steganography. It can make a JPEG image a container of a secret message, where no
      one knows the presence of the message except the sender and the intended receiver. In this
      programming work, we show how to realize the F5 algorithm via Matlab. We will present the
      block diagrams of embedding and extracting processes and the entire Matlab codes of the F5
      algorithm.
      4
      LIST OF FIGURES
      Figure 1: Block Diagram of F5 Embedding Process \u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026.7
      Figure 2: Block Diagram of F5 Extraction Process \u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026..16
      5<\/li>\n\n\n\n
    5. Introduction to JPEG-based Steganography
      Steganography is a data hiding technique that has been used in the applications of information
      protection. It transmits a secret message by hiding it into a cover object in order to create a
      hidden way of communication. Steganography has the same goal as cryptography since they aim
      to protect sensitive information. But they differ in the way of working; Cryptography converts the
      plain message into an unreadable encrypted message where the presence of the cryptography is
      not concealed, while steganography smuggles the message by embedding it into an innocentlooking
      object and thus creating an invisible communication channel.
      The techniques of steganography have been developed in the field of digital objects such as JPEG
      images, where we can make the JPEG image a container for a secret message by embedding the
      message Bits within it. The JPEG image will represent a hidden communication channel, where
      no one knows what it contains except the sender and intended receiver. Many JPEG-based
      steganographic methods have been invented in the DCT domain, including the F5 algorithm
      developed by Westfeld [1]. The F5 algorithm was born in 2001 and is still one of the more known
      methods.<\/li>\n\n\n\n
    6. F5 Steganographic Method
      Many of the DCT-based methods are based on the idea of a hash function. The function hashes a
      specific number (n) of quantized DCT coefficients (qDCT) to produce a specific number (k) of
      Bits. When the sender wants to embed a secret (k) Bits message, the (n) qDCT coefficients
      should be modified accordingly. Thus, when the receiver hashes the modified (n) qDCT
      coefficients, the hidden message is then obtained. The modifications are always constrained by
      requirements and rules depending on the considered algorithm.
      The F5 algorithm was proposed by Westfeld [1]. It is based on the idea of the matrix encoding
      (dmax, n, k) with dmax=1, where its goal is to minimize the number of changes made to the
      qDCT coefficients. The F5 algorithm takes (n) qDCT coefficients and hashes them to (k) Bits
      using a Xor-based hash function. When the sender needs a modification to embed the secret
      message, only one coefficient is changed since the resulting (n) qDCT coefficients should not
      have a hamming distance of more than dmax=1 from the original (n) qDCT coefficients. The (k)
      and (n) are calculated based on the original image capacity as well as the message length.<\/li>\n\n\n\n
    7. Matlab Implementation of F5 Algorithm
      3.1 Huffman Coding and Decoding
      The DCT-based steganographic methods are based on the idea of modifying the qDCT
      coefficients in such a way allowing to embed a stream of Bits. Thus, we need to have the ability
      to access the qDCT coefficients of a given JPEG file. The Matlab’s built-in functions used to
      handle digital images provide only basic conversion between the given JPEG file and image
      pixels. They don\u2019t give any access to the qDCT coefficients. In order to overcome this issue, we
      use a dedicated Matlab JPEG Toolbox developed by Sallee [2]. The used JPEG Toolbox contains
      special functions allowing to access and manipulate the qDCT coefficients of a given JPEG file.
      6
      The main two functions in the Sallee’s package \u201cjpeg_read\u201d and \u201cjpeg_write\u201d perform the steps
      of the lossless compression applied to the qDCT coefficients including Huffman coding and
      decoding. Thus, they provide more functionality, since they give the ability to gain direct access
      to all the structural elements of a JPEG file from Matlab, including the matrices of qDCT
      coefficients and the quantization tables.
      3.2 Implementation of F5 Embedding Process
      3.2.1 Steps of F5 Embedding Process
      In this section, we present a block diagram showing the implementation steps of the F5 algorithm
      on the sender side of the connection, where we hide the message file into a given JPEG image.
      At first, the \u201cjpeg_read\u201d function reads the given JPEG file and performs the entropy decoding.
      The \u201cjpeg_read\u201d function gives a Matlab structure containing the qDCT coefficients matrices,
      quantization tables, and other information. Only the qDCT coefficients matrix of Y component is
      used to embed the secret message because of its large size compared to those of the other two
      components.
      Before running the F5 embedding process, we should have two tasks completed:
      1- We define the matrix encoding ME by calculating the size of the message file and the
      number of Non-zero coefficients in the resulting Y matrix. The ME calculator gives the
      initial value of the matrix encoding that we should use in the embedding process.
      2- Typically, the embedding process should be protected and connected with a secret key.
      Thus, we should use a key-based permutation generator. The generated permutation is
      applied to the qDCT coefficients matrix of Y component before running the F5_ME
      embedding process.
      During the running of the F5 embedding process, we take into consideration the shrinkage of
      Non-zero qDCT coefficients, thus a shrinkage tester is always running. The tester aims to detect
      the occurrence of the shrinkage during the process, so the shrinking coefficient will be replaced
      by another one. In addition, the tester aims to ensure that the message file was embedded entirely
      according to the used ME, otherwise, the ME will be recalculated and the embedding process will
      be repeated according to the new ME.
      In the end, the resulting matrix is inversely permuted in order to get back the original order of the
      Y matrix of qDCT coefficients. The resulting qDCT coefficients matrix of Y component will then
      be in the same order as the original one, but with some modifications caused by the embedding
      process of the F5 algorithm. At this point, we write the resulting matrix to the Matlab JPEG
      structure and then use the \u201cjpeg_write\u201d function to perform the entropy coding in order to
      produce the Stego JPEG file that contains the secret message file. A block diagram of the F5
      embedding process is presented in Figure 1.
      7
      Fig 1: Block Diagram of F5 Embedding Process – Sender Side.
      8
      3.2.2 Main Script and Called Functions
      Main Script Called Functions m Files
      Msgsize Function Msgsize.m
      Qdct2Img Function Qdct2Img.m
      MediCap Function MediCap.m
      MatEncod Function MatEncod.m
      F5Embed Main Script – F5Embed.m GetkBits Function GetkBits.m
      DoEmbed Function DoEmbed.m
      DoStego Function DoStego.m
      F5Hash Function F5Hash.m
      DoChange Function DoChange.m
      HistPlot Function HistPlot.m
      3.2.3 Matlab Codes of F5 Embedding Process
      In this section, we present the entire Matlab codes, main script and called functions, that realize
      the embedding process of a secret message file whatever its extension.
      3.2.3.1 F5Embed Matlab Main Script
      clear all; close all; clc;
      OriginalImg=’CoverImage.JPG’; % Original image file – Cover Image.
      Messagefile=’Message.txt’; % Secret Message file, whatever the extension.
      SteganoImg=’StegoImage.JPG’; % Resulting image file – Stego Image.
      Msgbits=Msgsize(Messagefile);
      JPG=jpeg_read(OriginalImg); % Reading original image file \/ Huffman decoding.
      mat1=JPG.coef_arrays{1}; % Y component matrix
      Qtb1=JPG.quant_tables{JPG.comp_info(1).quant_tbl_no};
      img1= Qdct2Img(mat1,Qtb1);
      figure(1);
      imshow(img1); % showing Y component of the Original image.
      Cap=MediCap(mat1); % Calculating Nonzero coefficients.
      siz=size(mat1);
      Rw=siz(1); % rows : Height.
      Cl=siz(2); % columms : Width.
      CoefNb=ClRw; TmpBuff=zeros(1,CoefNb); % Temporary Buffer. RltBuff=zeros(1,CoefNb); % Resulting Buffer. % indx=0; for xx=1:Rw for yy=1:Cl indx=indx+1; TmpBuff(indx)=mat1(xx,yy); end end % Now, we have (indx=CoefNb). 9 % \u2026\u2026\u2026\u2026\u2026\u2026.. % At this point, a permutation should be applied to the Temporary Buffer : TmpBuff % \u2026\u2026\u2026\u2026\u2026\u2026.. Embrate= 100<\/em>(Msgbits\/Cap);
      Encod=MatEncod(Embrate); % Calculating Matrix Encoding.
      % \u2026\u2026\u2026\u2026\u2026\u2026.. Main Processing LOOP \u2026\u2026\u2026\u2026\u2026\u2026..
      WrkCn=0; % Counter of work process
      WrkDone=0;
      while(WrkDone==0) % Main Processing LOOP
      WrkCn=WrkCn+1;
      % Available codewords number (Cap\/n).
      AvalCdWd=(Cap-mod(Cap,Encod(2)))\/Encod(2);
      % Needed codewords number (Msgbits\/k).
      NeedCdWd=(Msgbits-mod(Msgbits,Encod(3)))\/Encod(3);
      % Stego Operation, We have : AvalCdWd > NeedCdWd
      SecData=GetkBits(Messagefile,Encod(3));
      mBuff=zeros(1,1);
      ShkgCn=0; % Shrinkage counter.
      cont=0; % (n) nonzero counter.
      indx=1;
      ix=1;
      CdWd=1; % Codeword index.
      while ((CdWd<=NeedCdWd) && (indx <= CoefNb)) while ((cont CoefNb) % The case where (indx) exceeded (CoefNb)
      Embrate=100(Encod(3)\/Encod(2)); Encod=MatEncod(Embrate); % Recalculating Encod WrkDone=0; % The work is NOT done end if (CdWd > NeedCdWd) % The case where the work is done WrkDone=1; end end % End of Main Processing LOOP % \u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026.. % \u2026\u2026\u2026\u2026\u2026End of Main Processing LOOP\u2026\u2026\u2026\u2026\u2026\u2026 % \u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026.. ChgMax=ShkgCn+NeedCdWd; % Maximum number of changes. BffLmt=indx-1; % Reached limit in TmpBuff. % End of Stego Operation % % Constructing Resulting Buffer : RltBuff Concat=[OutBuffs{1,1} OutBuffs{1,2}]; for i=3:NeedCdWd % Concatenation. Concat=[Concat OutBuffs{1,i}]; end Sz=size(Concat); for i=1:Sz(2) RltBuff(i)=Concat(i); end for i=Sz(2)+1:CoefNb RltBuff(i)=TmpBuff(i); end % \u2026\u2026\u2026\u2026\u2026\u2026.. % At this point, In case we used Permutation, The inverse Permutation % should be applied to the Resulting Buffer : RltBuff % \u2026\u2026\u2026\u2026\u2026\u2026.. % Histogram of resulting Buffer. figure(2); HH=HistPlot(RltBuff,25,0,0); % Constructing New Coefficients Matrix. siz=size(mat1); Rw=siz(1); % rows : Height. Cl=siz(2); % columms : Width. Nmat1=zeros(Rw,Cl); inx=0; for xx=1:Rw for yy=1:Cl inx=inx+1; Nmat1(xx,yy)=RltBuff(inx); end end % Now, we have (inx=CoefNb). % % Stego image Reconstruction JPG.coef_arrays{1}=Nmat1; % New Coefficients Matrix (Y component). jpeg_write(JPG,SteganoImg); % 11 % showing the Stego image (Y component). JPG=jpeg_read(SteganoImg); mat1=JPG.coef_arrays{1}; Qtb1=JPG.quant_tables{JPG.comp_info(1).quant_tbl_no}; img2= Qdct2Img(mat1,Qtb1); figure(3); imshow(img2); % 3.2.3.2 Msgsize Matlab Function function bitSize=Msgsize(msgfile) % fileObj = memmapfile(msgfile); siz = size(fileObj.data); FileSiz=siz(1); % File Size in Bytes. bitSize= FileSiz<\/em>8; % File Size in Bits.
      %
      3.2.3.3 Qdct2Img Matlab Function
      function img_mat= Qdct2Img(qdct_mat,Qtbl)
      % This function computes the Image
      % matrix of the considered component.
      demat=dequantize(qdct_mat,Qtbl);
      img_mat0=ibdct(demat)+128;
      img_mat=uint8(img_mat0);
      %
      3.2.3.4 MediCap Matlab Function
      function Cap=MediCap(mat)
      % mat : Y component matrix.
      siz=size(mat);
      Rw=siz(1); % rows : Height.
      Cl=siz(2); % columms : Width.
      % Calculating the number of
      % Nonzero coefficients.
      cout=0;
      for xx=1:Rw
      for yy=1:Cl
      if (mat(xx,yy)~=0)
      cout=cout+1;
      end
      end
      end
      Cap=cout;
      %
      12
      3.2.3.5 MatEncod Matlab Function
      function Encod=MatEncod(Embrate)
      % Calculating the matrix encoding
      Encod=[1 1 1];
      k=0;
      Diff=1;
      while (Diff>0)
      k=k+1;
      R=100(k \/((2^k)-1)); Diff=R-Embrate; end k=k-1; n=(2^k)-1; Encod(2)=n; Encod(3)=k; % 3.2.3.6 GetkBits Matlab Function function SecData=GetkBits(msgfile,k) % Distribute the information to be hidden on a matrix % Creating a matrix (SecData) including the Bits stream % of the secret message file according to (k) value. % msgfile : File name String. % k : Embeded data size. Frmt=[‘ubit’ int2str(k)]; Msgbits=Msgsize(msgfile); Nb=(Msgbits-mod(Msgbits,k))\/k; SecData=zeros(1,Nb); fid=fopen(msgfile,’r’); for idx=1:Nb SecData(idx)= fread(fid,1,Frmt); end fclose(fid); % 13 3.2.3.7 DoEmbed Matlab Function function MBuff_shk=DoEmbed(mBuff,m,n,DesiredVal) % mBuff has the size (m) and contains (m) qDCT coefficients. % mBuff contains (n) Nonzero qDCT coefficients. % m >= n % m : loop-changeable value. % n : the encoding value, Matrix Encoding =(1,n,k). % DesiredVal : the desired value to be embedded. % DesiredVal will be within [0,1,..,n], k Bits. nBuff=zeros(1,n); j=0; for i=1:m if (mBuff(i)~=0) % Nonzero values. j=j+1; nBuff(j)=mBuff(i); mBuff(i)=0.5; % Marking the Nonzero value locations. end end % Now, we have (j=n). NBuff=zeros(1,n); % Appling F5 algorithm on nBuff. if(j==n) NBuff=DoStego(nBuff,n,DesiredVal); end % Reforming mBuff. % Shrinkage Testing in steganographed NBuff. Shk=0; % Shrinkage Indicator. ShkPt=0; % Shrinkage Position. j=0; for i=1:m if (mBuff(i)==0.5) j=j+1; mBuff(i)=NBuff(j); if (NBuff(j)==0) % Shrinkage Test. Shk=1; % Shrinkage Indicator. ShkPt=i; % Shrinkage Position. end end end % Now, we have (j=n) % mBuff has been modified\/steganographed. % % Returning modified buffer % and shrinkage indicator. MBuff=mBuff; MBuff_shk={MBuff,Shk,ShkPt}; % 14 3.2.3.8 DoStego Matlab Function function stegoBuff=DoStego(Buff,n,DesiredVal) % Buff contains (n) qDCTs coefficients. % DesiredVal is the desired value to be embedded. % DesiredVal will be within [0,1,..,n]. % % Calculating the current Hash value. CurrentVal=F5Hash(Buff,n); % XORing desired and current values % in order to find bit location (S) to modify. S= bitxor(DesiredVal,CurrentVal); % Applying the (d=1) modification : % changing the buffer by One change NewBuff=DoChange(Buff,S); % Calculating the New Hash value. NewVal=F5Hash(NewBuff,n); % Comparing between % New and Desired values % Returning the stego Buffer. if (NewVal==DesiredVal) % Must be always true. stegoBuff=NewBuff; elseif (NewVal~=DesiredVal) stegoBuff=0; end % 3.2.3.9 F5Hash Matlab Function function Hash = F5Hash(Buff,n) % F5 algorithm Hash function % Buff contains (n) qDCTs coefficients. ABuff= abs(Buff); % (ai) Bits do not change. B=ones(1,n); a = bitand(ABuff,B); % Extracting (ai) Bits values. %%% indx=zeros(1,n); for i=1:n indx(i)=i; end %%% idx=a.<\/em>indx; % Multiplying element by element.
      %%%
      hsh=idx(1);
      for i=2:n
      hsh= bitxor(hsh,idx(i));
      end
      Hash=hsh; % Resulting Hash Value.
      %
      15
      3.2.3.10 DoChange Matlab Function
      function NewBuff=DoChange(Buff,S)
      % (S) points to the bit location that must be changed
      % Treatement Only in case of (S>0), If (S=0) there is NO changment.
      if (S>0)
      if (Buff(S)> 0) % Positive qDCT Value.
      Buff(S)= Buff(S)-1;
      elseif (Buff(S)< 0) % Negative qDCT Value.
      Buff(S) = (-1)(abs(Buff(S))-1); end end NewBuff=Buff; % 3.2.3.11 HistPlot Matlab Function function HH=HistPlot(Vec,Rang,MaxCH,MaxCnt) HH=zeros(1,3); siz=size(Vec); [n,xout]=hist(Vec,-Rang:Rang); ToTNb=sum(n); HH(1)=ToTNb; XNb=(2<\/em>Rang)+1;
      HH(2)=n(1)+n(XNb);
      %%%
      n(1)=0;
      n(XNb)=0;
      if (ToTNb==siz(2) && MaxCH==1)
      for i=1:XNb
      if(xout(i)==0)
      HH(3)=n(i);
      n(i)=MaxCnt;
      end
      end
      end
      bar(xout,n);
      %
      16
      3.3 Implementation of F5 Extracting Process
      3.3.1 Steps of F5 Extracting Process
      In this section, we present a block diagram showing the implementation steps of the F5 algorithm
      on the receiver side of the connection, where we extract the hidden message file from the
      received Stego JPEG file.
      At first, the Stego JPEG file is read (red) by the \u201cjpeg_read\u201d Matlab function which gives a
      Matlab structure containing the qDCT coefficients matrices. The qDCT coefficients matrix of Y
      component is then permuted using the same permutation generator and key which were used in
      the sender side. After permutation, we obtain the matrix in the same order that was used during
      the embedding process. The F5 algorithm will then hash the permuted matrix using the same
      matrix encoding ME that was used during the embedding process in order to get the hidden
      message File. A block diagram of the F5 extraction process is presented in Figure 2.
      Fig 2: Block Diagram of F5 Extraction Process – Receiver Side.
      17
      3.3.2 Main Script and Called Functions
      Main Script Called Functions m Files
      MediCap Function MediCap.m
      F5Extract Main Script – F5Extract.m DoExtract Function DoExtract.m
      F5Hash Function F5Hash.m
      3.3.3 Matlab Codes of F5 Extracting Process
      In this section, we present the entire Matlab codes, main script and called functions, that realize
      the extracting process of the hidden message file. In order to extract the hidden file correctly, the
      Value of the Matrix Encoding, must be set as calculated in the embedding process.
      3.3.3.1 F5Extract Matlab Main Script
      clear all;close all; clc;
      % In order to extract the hidden file correctly, the Value
      % of Encod (Matrix Encoding) must be set as calculated in
      % the embedding process : F5Embed.m .
      % Used Matrix Encoding
      Encod=[1 15 4]; % [1 7 3],[1,31,5],[1,63,6],[1,255,8];
      %
      StegoIm=’StegoImage.JPG’; % Received Stego Image file.
      Rcvmsg=’Extracted.txt’; % Extracted Hidden Message file.
      %
      JPG=jpeg_read(StegoIm);
      mat1=JPG.coef_arrays{1};
      Cap=MediCap(mat1);
      % Available codewords number (Cap\/n).
      AvalCdWd=(Cap-mod(Cap,Encod(2)))\/Encod(2);
      %
      siz=size(mat1);
      Rw=siz(1); % rows : Height.
      Cl=siz(2); % columms : Width.
      CoefNb=Cl*Rw;
      TmpBuff=zeros(1,CoefNb);
      mBuff=zeros(1,1);
      %
      indx=0;
      for xx=1:Rw
      for yy=1:Cl
      indx=indx+1;
      TmpBuff(indx)=mat1(xx,yy);
      end
      end
      18
      % \u2026\u2026\u2026\u2026\u2026\u2026..
      % At this point, we should apply the same permutation
      % which was used in the embedding process to TmpBuff.
      % \u2026\u2026\u2026\u2026\u2026\u2026..
      cont=0;
      CdWd=1;
      indx=1;
      ix=1;
      ExVal=0;
      while(CdWd<=AvalCdWd) % Extraction LOOP
      while (cont<Encod(2))
      if (TmpBuff(indx)==0)
      mBuff(ix)=TmpBuff(indx);
      indx=indx+1;
      ix=ix+1;
      elseif (TmpBuff(indx)~=0)
      mBuff(ix)=TmpBuff(indx);
      cont=cont+1;
      indx=indx+1;
      ix=ix+1;
      end
      end
      m=ix-1; % The bufferd number.
      ExVal=[ExVal DoExtract(mBuff,m,Encod(2))];
      CdWd=CdWd+1;
      mBuff=zeros(1,1);
      ix=1;
      cont=0;
      end % End of Extraction LOOP
      % \u2026\u2026\u2026\u2026\u2026\u2026.. % End of Extraction LOOP
      % \u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026
      % Writing extracted Bits stream to a file (secret message file).
      k=Encod(3);
      Frmt=[‘ubit’ int2str(k)];
      fid=fopen(Rcvmsg,’w’);
      for i=2:AvalCdWd+1
      count = fwrite(fid,ExVal(i),Frmt); % Creating the output file.
      end
      fclose(fid);
      %
      3.3.3.2 MediCap Matlab Function
      The function here is the same as in the section 3.2.3.4 .
      19
      3.3.3.3 DoExtract Matlab Function
      function ExVal=DoExtract(mBuff,m,n)
      %
      nBuff=zeros(1,n);
      j=0;
      for i=1:m
      if (mBuff(i)~=0) % Nonzero values.
      j=j+1;
      nBuff(j)=mBuff(i);
      end
      end
      % Now, we have (j=n).
      % Calculating the F5 Hash value.
      ExVal=F5Hash(nBuff,n);
      %
      3.3.3.4 F5Hash Matlab Function
      The function here is the same as in the section 3.2.3.9 .<\/li>\n\n\n\n
    8. Programming Notes:
      1- In the DCT-based steganography, we need to have direct access to qDCT coefficients.
      The toolbox of Sallee made it easier for us to access and manipulate the qDCT
      coefficients where the main two functions of the package perform the standard steps of
      lossless compression including Huffman Coding and decoding. This toolbox provides
      complete control over all internal contents of the JPEG image file, thus it can be used in
      many applications especially in DCT-based steganography.
      2- The embedding program starts from a given JPEG file stored on a digital storage unit and
      ends with an output Stego JPEG file to be stored or to be sent over the network. Therefore,
      Removing the codes of showing the images and histogram doesn\u2019t affect the main
      function of the program.
      3- The secret message file can be any file of any kind and whatever its extension. The
      embedding and extracting programs deal with the message file as a series of Bits.
      4- The shrinkage happening to qDCT coefficients during the embedding process is a subject
      to probability. It may affect the capacity of the image since it causes a decrease in the
      number of Non-zero qDCT coefficients. Therefore, the possibility of modifying the
      initially calculated value of ME during the embedding process and thus repeating the
      process should be taken into consideration.
      5- In the presented program, the part related to the permutation is left blank where the
      programmer can add his own codes accordingly. The programmer can build a permutation
      generator based on a pseudo-random generator and connect it to a key.
      20
      References
      [1] A. Westfeld. \u201cF5 \u2014 a steganographic algorithm \u2014 high capacity despite better
      steganalysis\u201d: Information Hiding, Fourth International Workshop, Lecture Notes
      in Computer Science vol. 2137, 289\u2013302, 2001.
      [2] Phil Sallee. \u201cMatlab JPEG Toolbox\u201d: Original package: jpegtbx_1.4, Sep 2003.<\/li>\n<\/ol>\n","protected":false},"excerpt":{"rendered":"

      Wassim Al ChamaaMATLAB Implementation of theSteganographic Algorithm F5Matlab Codes for F5 AlgorithmProject ReportComputer Science Bibliographic information published by the German National Library:The German National Library lists this publication in the National Bibliography;detailed bibliographic data are available on the Internet at http:\/\/dnb.dnb.de .This book is copyright material and must not be copied, reproduced, transferred,distributed, leased, licensed […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-17","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/www.tim.alchamaa.com\/index.php?rest_route=\/wp\/v2\/pages\/17","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.tim.alchamaa.com\/index.php?rest_route=\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.tim.alchamaa.com\/index.php?rest_route=\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.tim.alchamaa.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tim.alchamaa.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=17"}],"version-history":[{"count":1,"href":"https:\/\/www.tim.alchamaa.com\/index.php?rest_route=\/wp\/v2\/pages\/17\/revisions"}],"predecessor-version":[{"id":18,"href":"https:\/\/www.tim.alchamaa.com\/index.php?rest_route=\/wp\/v2\/pages\/17\/revisions\/18"}],"wp:attachment":[{"href":"https:\/\/www.tim.alchamaa.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=17"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}