From: couchot Date: Tue, 2 Oct 2012 13:55:22 +0000 (+0200) Subject: reprise des négociations X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/canny.git/commitdiff_plain/70660073a3e38d00d230d6be415339e48cc23ead?ds=inline;hp=-c reprise des négociations --- 70660073a3e38d00d230d6be415339e48cc23ead diff --git a/biblio.bib b/biblio.bib index bfb99b1..47c0c00 100644 --- a/biblio.bib +++ b/biblio.bib @@ -2,7 +2,7 @@ author = {Dumitrescu, Sorina and Wu, Xiaolin}, title = {LSB steganalysis based on high-order statistics}, booktitle = {Proceedings of the 7th workshop on Multimedia and security}, - series = {MM\&\#38;Sec '05}, + series = {MMSec '05}, year = {2005}, isbn = {1-59593-032-9}, location = {New York, NY, USA}, @@ -54,3 +54,323 @@ author = {Jessica J. Fridrich and note = {to appear} } +@article{DBLP:journals/tsp/DumitrescuWW03, + added-at = {2012-02-06T00:00:00.000+0100}, + author = {Dumitrescu, Sorina and Wu, Xiaolin and Wang, Zhe}, + biburl = {http://www.bibsonomy.org/bibtex/2556caad9b61980d3458885153a52321c/dblp}, + ee = {http://dx.doi.org/10.1109/TSP.2003.812753}, + interhash = {f51bec0b4e4f8aba644eb0938018d2c6}, + intrahash = {556caad9b61980d3458885153a52321c}, + journal = {IEEE Transactions on Signal Processing}, + keywords = {dblp}, + number = 7, + pages = {1995-2007}, + timestamp = {2012-02-06T00:00:00.000+0100}, + title = {Detection of LSB steganography via sample pair analysis.}, + url = {http://dblp.uni-trier.de/db/journals/tsp/tsp51.html#DumitrescuWW03}, + volume = 51, + year = 2003 +} + +@inproceedings{DBLP:conf/mmsec/FridrichGD01, + added-at = {2007-10-26T00:00:00.000+0200}, + author = {Fridrich, Jessica J. and Goljan, Miroslav and Du, Rui}, + biburl = {http://www.bibsonomy.org/bibtex/21c12d6fb5f949f98fabe4ee75cab4f8b/dblp}, + booktitle = {MMSec}, + crossref = {DBLP:conf/mmsec/2001}, + date = {2007-10-26}, + description = {dblp}, + editor = {Georganas, Nicolas D. and Popescu-Zeletin, Radu}, + ee = {http://doi.acm.org/10.1145/1232454.1232466}, + interhash = {de49b3b9958119616eee66f14060f47f}, + intrahash = {1c12d6fb5f949f98fabe4ee75cab4f8b}, + isbn = {1-58113-393-6}, + keywords = {dblp}, + pages = {27-30}, + publisher = {ACM}, + timestamp = {2007-10-26T00:00:00.000+0200}, + title = {Reliable detection of LSB steganography in color and grayscale images.}, + url = {http://dblp.uni-trier.de/db/conf/mmsec/mmsec2001.html#FridrichGD01}, + year = 2001 +} + + +@proceedings{DBLP:conf/mmsec/2001, + editor = {Nicolas D. Georganas and + Radu Popescu-Zeletin}, + title = {Proceedings of the 4th workshop on Multimedia {\&} Security: + New Challenges, MM{\&}Sec 2001, Ottawa, Ontario, Canada, + October 5, 2001}, + booktitle = {MM{\&}Sec}, + publisher = {ACM}, + year = {2001}, + isbn = {1-58113-393-6}, + bibsource = {DBLP, http://dblp.uni-trier.de} +} + +@inproceedings{DBLP:conf/ih/PevnyFB10, + added-at = {2010-10-08T00:00:00.000+0200}, + author = {Pevný, Tomás and Filler, Tomás and Bas, Patrick}, + biburl = {http://www.bibsonomy.org/bibtex/28d83b7eac2c22ed5e7e072fd43a34248/dblp}, + booktitle = {Information Hiding}, + crossref = {DBLP:conf/ih/2010}, + editor = {Böhme, Rainer and Fong, Philip W. L. and Safavi-Naini, Reihaneh}, + ee = {http://dx.doi.org/10.1007/978-3-642-16435-4_13}, + interhash = {b30869c1bb39a2c15b33e05e5139e58b}, + intrahash = {8d83b7eac2c22ed5e7e072fd43a34248}, + isbn = {978-3-642-16434-7}, + keywords = {dblp}, + pages = {161-177}, + publisher = {Springer}, + series = {Lecture Notes in Computer Science}, + timestamp = {2010-10-08T00:00:00.000+0200}, + title = {Using High-Dimensional Image Models to Perform Highly Undetectable Steganography.}, + url = {http://dblp.uni-trier.de/db/conf/ih/ih2010.html#PevnyFB10}, + volume = 6387, + year = 2010 +} + +@proceedings{DBLP:conf/ih/2010, + editor = {Rainer B{\"o}hme and + Philip W. L. Fong and + Reihaneh Safavi-Naini}, + title = {Information Hiding - 12th International Conference, IH 2010, + Calgary, AB, Canada, June 28-30, 2010, Revised Selected + Papers}, + booktitle = {Information Hiding}, + publisher = {Springer}, + series = {Lecture Notes in Computer Science}, + volume = {6387}, + year = {2010}, + isbn = {978-3-642-16434-7}, + ee = {http://dx.doi.org/10.1007/978-3-642-16435-4}, + bibsource = {DBLP, http://dblp.uni-trier.de} +} + + +@article{DBLP:journals/eswa/ChenCL10, + added-at = {2010-07-21T15:44:10.000+0200}, + author = {Chen, Wen-Jan and Chang, Chin-Chen and Le, T. Hoang Ngan}, + biburl = {http://www.bibsonomy.org/bibtex/228889a4ab329da28559f0910469f054b/dblp}, + date = {2010-05-03}, + ee = {http://dx.doi.org/10.1016/j.eswa.2009.09.050}, + interhash = {bc34a5f04661fee24ee62c39e76361be}, + intrahash = {28889a4ab329da28559f0910469f054b}, + journal = {Expert Syst. Appl.}, + keywords = {dblp}, + number = 4, + pages = {3292-3301}, + timestamp = {2010-07-21T15:44:10.000+0200}, + title = {High payload steganography mechanism using hybrid edge detector.}, + url = {http://dblp.uni-trier.de/db/journals/eswa/eswa37.html#ChenCL10}, + volume = 37, + year = 2010 +} + +@article{DBLP:journals/tifs/FillerJF11, + added-at = {2011-09-29T00:00:00.000+0200}, + author = {Filler, Tomás and Judas, Jan and Fridrich, Jessica J.}, + biburl = {http://www.bibsonomy.org/bibtex/250e43c05a74eec17524b3df8db442da5/dblp}, + ee = {http://dx.doi.org/10.1109/TIFS.2011.2134094}, + interhash = {b27d23ed0c9936d568e16c51378abccd}, + intrahash = {50e43c05a74eec17524b3df8db442da5}, + journal = {IEEE Transactions on Information Forensics and Security}, + keywords = {dblp}, + number = {3-2}, + pages = {920-935}, + timestamp = {2011-09-29T00:00:00.000+0200}, + title = {Minimizing Additive Distortion in Steganography Using Syndrome-Trellis Codes.}, + url = {http://dblp.uni-trier.de/db/journals/tifs/tifs6.html#FillerJF11}, + volume = 6, + year = 2011 +} + + + +@inproceedings{DBLP:conf/ih/Westfeld01, + added-at = {2011-06-28T00:00:00.000+0200}, + author = {Westfeld, Andreas}, + biburl = {http://www.bibsonomy.org/bibtex/2fea2c6aabf7eba19ceaec93f913e5d8d/dblp}, + booktitle = {Information Hiding}, + crossref = {DBLP:conf/ih/2001}, + editor = {Moskowitz, Ira S.}, + ee = {http://dx.doi.org/10.1007/3-540-45496-9_21}, + interhash = {e7eaa917e995dc9373f10304d3e79255}, + intrahash = {fea2c6aabf7eba19ceaec93f913e5d8d}, + isbn = {3-540-42733-3}, + keywords = {dblp}, + pages = {289-302}, + publisher = {Springer}, + series = {Lecture Notes in Computer Science}, + timestamp = {2011-06-28T00:00:00.000+0200}, + title = {F5-A Steganographic Algorithm.}, + url = {http://dblp.uni-trier.de/db/conf/ih/ihw2001.html#Westfeld01}, + volume = 2137, + year = 2001 +} + +@proceedings{DBLP:conf/ih/2001, + editor = {Ira S. Moskowitz}, + title = {Information Hiding, 4th International Workshop, IHW 2001, + Pittsburgh, PA, USA, April 25-27, 2001, Proceedings}, + booktitle = {Information Hiding}, + publisher = {Springer}, + series = {Lecture Notes in Computer Science}, + volume = {2137}, + year = {2001}, + isbn = {3-540-42733-3}, + bibsource = {DBLP, http://dblp.uni-trier.de} +} + +@inproceedings{DBLP:conf/ih/KimDR06, + added-at = {2007-09-20T00:00:00.000+0200}, + author = {Kim, Younhee and Duric, Zoran and Richards, Dana}, + biburl = {http://www.bibsonomy.org/bibtex/2f0324f70d62d9dfba568e393920aaa16/dblp}, + booktitle = {Information Hiding}, + crossref = {DBLP:conf/ih/2006}, + date = {2007-09-20}, + description = {dblp}, + editor = {Camenisch, Jan and Collberg, Christian S. and Johnson, Neil F. and Sallee, Phil}, + ee = {http://dx.doi.org/10.1007/978-3-540-74124-4_21}, + interhash = {399aab122b39cfd6f6e951a1b276c786}, + intrahash = {f0324f70d62d9dfba568e393920aaa16}, + isbn = {978-3-540-74123-7}, + keywords = {dblp}, + pages = {314-327}, + publisher = {Springer}, + series = {Lecture Notes in Computer Science}, + timestamp = {2007-09-20T00:00:00.000+0200}, + title = {Modified Matrix Encoding Technique for Minimal Distortion Steganography.}, + url = {http://dblp.uni-trier.de/db/conf/ih/ih2006.html#KimDR06}, + volume = 4437, + year = 2006 +} + + +@proceedings{DBLP:conf/ih/2006, + editor = {Jan Camenisch and + Christian S. Collberg and + Neil F. Johnson and + Phil Sallee}, + title = {Information Hiding, 8th International Workshop, IH 2006, + Alexandria, VA, USA, July 10-12, 2006. Revised Selcted Papers}, + booktitle = {Information Hiding}, + publisher = {Springer}, + series = {Lecture Notes in Computer Science}, + volume = {4437}, + year = {2007}, + isbn = {978-3-540-74123-7}, + bibsource = {DBLP, http://dblp.uni-trier.de} +} + +@inproceedings{DBLP:conf/mmsec/FridrichPK07, + added-at = {2007-10-26T00:00:00.000+0200}, + author = {Fridrich, Jessica J. and Pevný, Tomás and Kodovský, Jan}, + biburl = {http://www.bibsonomy.org/bibtex/26123ac512b5e1fe72a44e73d101d8b95/dblp}, + booktitle = {MMSec}, + crossref = {DBLP:conf/mmsec/2007}, + date = {2007-10-26}, + description = {dblp}, + editor = {Kundur, Deepa and Prabhakaran, Balakrishnan and Dittmann, Jana and Fridrich, Jessica J.}, + ee = {http://doi.acm.org/10.1145/1288869.1288872}, + interhash = {35c4a20b41b7861bcb09c9ff335ac601}, + intrahash = {6123ac512b5e1fe72a44e73d101d8b95}, + isbn = {978-1-59593-857-2}, + keywords = {dblp}, + pages = {3-14}, + publisher = {ACM}, + timestamp = {2007-10-26T00:00:00.000+0200}, + title = {Statistically undetectable jpeg steganography: dead ends challenges, and opportunities.}, + url = {http://dblp.uni-trier.de/db/conf/mmsec/mmsec2007.html#FridrichPK07}, + year = 2007 +} + +@proceedings{DBLP:conf/mmsec/2007, + editor = {Deepa Kundur and + Balakrishnan Prabhakaran and + Jana Dittmann and + Jessica J. Fridrich}, + title = {Proceedings of the 9th workshop on Multimedia {\&} Security, + MM{\&}Sec 2007, Dallas, Texas, USA, September 20-21, 2007}, + booktitle = {MM{\&}Sec}, + publisher = {ACM}, + year = {2007}, + isbn = {978-1-59593-857-2}, + bibsource = {DBLP, http://dblp.uni-trier.de} +} + +@inproceedings{DBLP:conf/mediaforensics/FillerJF10, + added-at = {2010-08-21T00:00:00.000+0200}, + author = {Filler, Tomás and Judas, Jan and Fridrich, Jessica J.}, + biburl = {http://www.bibsonomy.org/bibtex/23405985533dce431b5013941a2c2c2cc/dblp}, + booktitle = {Media Forensics and Security}, + crossref = {DBLP:conf/mediaforensics/2010}, + editor = {Memon, Nasir D. and Dittmann, Jana and Alattar, Adnan M. and Delp, Edward J.}, + ee = {http://dx.doi.org/10.1117/12.838002}, + interhash = {a3d2215b959361a30f0b48f15c012bc9}, + intrahash = {3405985533dce431b5013941a2c2c2cc}, + isbn = {978-0-8194-7934-1}, + keywords = {dblp}, + pages = 754105, + publisher = {SPIE}, + series = {SPIE Proceedings}, + timestamp = {2010-08-21T00:00:00.000+0200}, + title = {Minimizing embedding impact in steganography using trellis-coded quantization.}, + url = {http://dblp.uni-trier.de/db/conf/mediaforensics/mediaforensics2010.html#FillerJF10}, + volume = 7541, + year = 2010 +} + + +@proceedings{DBLP:conf/mediaforensics/2010, + editor = {Nasir D. Memon and + Jana Dittmann and + Adnan M. Alattar and + Edward J. Delp}, + title = {Media Forensics and Security II, part of the IS{\&}T-SPIE + Electronic Imaging Symposium, San Jose, CA, USA, January + 18-20, 2010, Proceedings}, + booktitle = {Media Forensics and Security}, + publisher = {SPIE}, + series = {SPIE Proceedings}, + volume = {7541}, + year = {2010}, + isbn = {978-0-8194-7934-1}, + bibsource = {DBLP, http://dblp.uni-trier.de} +} + + +@article{Luo:2010:EAI:1824719.1824720, + author = {Luo, Weiqi and Huang, Fangjun and Huang, Jiwu}, + title = {Edge adaptive image steganography based on LSB matching revisited}, + journal = {Trans. Info. For. Sec.}, + issue_date = {June 2010}, + volume = {5}, + number = {2}, + month = jun, + year = {2010}, + issn = {1556-6013}, + pages = {201--214}, + numpages = {14}, + url = {http://dx.doi.org/10.1109/TIFS.2010.2041812}, + doi = {10.1109/TIFS.2010.2041812}, + acmid = {1824720}, + publisher = {IEEE Press}, + address = {Piscataway, NJ, USA}, + keywords = {Content-based steganography, content-based steganography, least-significant-bit (LSB)-based steganography, pixel-value differencing (PVD), security, steganalysis}, +} + +@article{Mielikainen06, + author = {Mielikainen, J.}, + title = {LSB Matching Revisited}, + journal = {Signal Processing Letters}, + year = {2006}, + OPTkey = {}, + volume = {13}, + number = {5}, + pages = {285--287}, + month = may, + OPTnote = {}, + OPTannote = {} +} + diff --git a/main.tex b/main.tex index a175e8a..fcbcdbb 100755 --- a/main.tex +++ b/main.tex @@ -1,324 +1,7 @@ \documentclass[draft,journal]{IEEEtran} -% -% If IEEEtran.cls has not been installed into the LaTeX system files, -% manually specify the path to it like: -% \documentclass[journal]{../sty/IEEEtran} - - - - - -% Some very useful LaTeX packages include: -% (uncomment the ones you want to load) - - -% *** MISC UTILITY PACKAGES *** -% -%\usepackage{ifpdf} -% Heiko Oberdiek's ifpdf.sty is very useful if you need conditional -% compilation based on whether the output is pdf or dvi. -% usage: -% \ifpdf -% % pdf code -% \else -% % dvi code -% \fi -% The latest version of ifpdf.sty can be obtained from: -% http://www.ctan.org/tex-archive/macros/latex/contrib/oberdiek/ -% Also, note that IEEEtran.cls V1.7 and later provides a builtin -% \ifCLASSINFOpdf conditional that works the same way. -% When switching from latex to pdflatex and vice-versa, the compiler may -% have to be run twice to clear warning/error messages. - - - - - - -% *** CITATION PACKAGES *** -% -%\usepackage{cite} -% cite.sty was written by Donald Arseneau -% V1.6 and later of IEEEtran pre-defines the format of the cite.sty package -% \cite{} output to follow that of IEEE. Loading the cite package will -% result in citation numbers being automatically sorted and properly -% "compressed/ranged". e.g., [1], [9], [2], [7], [5], [6] without using -% cite.sty will become [1], [2], [5]--[7], [9] using cite.sty. cite.sty's -% \cite will automatically add leading space, if needed. Use cite.sty's -% noadjust option (cite.sty V3.8 and later) if you want to turn this off. -% cite.sty is already installed on most LaTeX systems. Be sure and use -% version 4.0 (2003-05-27) and later if using hyperref.sty. cite.sty does -% not currently provide for hyperlinked citations. -% The latest version can be obtained at: -% http://www.ctan.org/tex-archive/macros/latex/contrib/cite/ -% The documentation is contained in the cite.sty file itself. - - - - - - -% *** GRAPHICS RELATED PACKAGES *** -% -\ifCLASSINFOpdf - % \usepackage[pdftex]{graphicx} - % declare the path(s) where your graphic files are - % \graphicspath{{../pdf/}{../jpeg/}} - % and their extensions so you won't have to specify these with - % every instance of \includegraphics - % \DeclareGraphicsExtensions{.pdf,.jpeg,.png} -\else - % or other class option (dvipsone, dvipdf, if not using dvips). graphicx - % will default to the driver specified in the system graphics.cfg if no - % driver is specified. - % \usepackage[dvips]{graphicx} - % declare the path(s) where your graphic files are - % \graphicspath{{../eps/}} - % and their extensions so you won't have to specify these with - % every instance of \includegraphics - % \DeclareGraphicsExtensions{.eps} -\fi -% graphicx was written by David Carlisle and Sebastian Rahtz. It is -% required if you want graphics, photos, etc. graphicx.sty is already -% installed on most LaTeX systems. The latest version and documentation can -% be obtained at: -% http://www.ctan.org/tex-archive/macros/latex/required/graphics/ -% Another good source of documentation is "Using Imported Graphics in -% LaTeX2e" by Keith Reckdahl which can be found as epslatex.ps or -% epslatex.pdf at: http://www.ctan.org/tex-archive/info/ -% -% latex, and pdflatex in dvi mode, support graphics in encapsulated -% postscript (.eps) format. pdflatex in pdf mode supports graphics -% in .pdf, .jpeg, .png and .mps (metapost) formats. Users should ensure -% that all non-photo figures use a vector format (.eps, .pdf, .mps) and -% not a bitmapped formats (.jpeg, .png). IEEE frowns on bitmapped formats -% which can result in "jaggedy"/blurry rendering of lines and letters as -% well as large increases in file sizes. -% -% You can find documentation about the pdfTeX application at: -% http://www.tug.org/applications/pdftex - - - - - -% *** MATH PACKAGES *** -% -%\usepackage[cmex10]{amsmath} -% A popular package from the American Mathematical Society that provides -% many useful and powerful commands for dealing with mathematics. If using -% it, be sure to load this package with the cmex10 option to ensure that -% only type 1 fonts will utilized at all point sizes. Without this option, -% it is possible that some math symbols, particularly those within -% footnotes, will be rendered in bitmap form which will result in a -% document that can not be IEEE Xplore compliant! -% -% Also, note that the amsmath package sets \interdisplaylinepenalty to 10000 -% thus preventing page breaks from occurring within multiline equations. Use: -%\interdisplaylinepenalty=2500 -% after loading amsmath to restore such page breaks as IEEEtran.cls normally -% does. amsmath.sty is already installed on most LaTeX systems. The latest -% version and documentation can be obtained at: -% http://www.ctan.org/tex-archive/macros/latex/required/amslatex/math/ - - - - - -% *** SPECIALIZED LIST PACKAGES *** -% -%\usepackage{algorithmic} -% algorithmic.sty was written by Peter Williams and Rogerio Brito. -% This package provides an algorithmic environment fo describing algorithms. -% You can use the algorithmic environment in-text or within a figure -% environment to provide for a floating algorithm. Do NOT use the algorithm -% floating environment provided by algorithm.sty (by the same authors) or -% algorithm2e.sty (by Christophe Fiorio) as IEEE does not use dedicated -% algorithm float types and packages that provide these will not provide -% correct IEEE style captions. The latest version and documentation of -% algorithmic.sty can be obtained at: -% http://www.ctan.org/tex-archive/macros/latex/contrib/algorithms/ -% There is also a support site at: -% http://algorithms.berlios.de/index.html -% Also of interest may be the (relatively newer and more customizable) -% algorithmicx.sty package by Szasz Janos: -% http://www.ctan.org/tex-archive/macros/latex/contrib/algorithmicx/ - - - - -% *** ALIGNMENT PACKAGES *** -% -%\usepackage{array} -% Frank Mittelbach's and David Carlisle's array.sty patches and improves -% the standard LaTeX2e array and tabular environments to provide better -% appearance and additional user controls. As the default LaTeX2e table -% generation code is lacking to the point of almost being broken with -% respect to the quality of the end results, all users are strongly -% advised to use an enhanced (at the very least that provided by array.sty) -% set of table tools. array.sty is already installed on most systems. The -% latest version and documentation can be obtained at: -% http://www.ctan.org/tex-archive/macros/latex/required/tools/ - - -%\usepackage{mdwmath} -%\usepackage{mdwtab} -% Also highly recommended is Mark Wooding's extremely powerful MDW tools, -% especially mdwmath.sty and mdwtab.sty which are used to format equations -% and tables, respectively. The MDWtools set is already installed on most -% LaTeX systems. The lastest version and documentation is available at: -% http://www.ctan.org/tex-archive/macros/latex/contrib/mdwtools/ - - -% IEEEtran contains the IEEEeqnarray family of commands that can be used to -% generate multiline equations as well as matrices, tables, etc., of high -% quality. - - -%\usepackage{eqparbox} -% Also of notable interest is Scott Pakin's eqparbox package for creating -% (automatically sized) equal width boxes - aka "natural width parboxes". -% Available at: -% http://www.ctan.org/tex-archive/macros/latex/contrib/eqparbox/ - - - - - -% *** SUBFIGURE PACKAGES *** -%\usepackage[tight,footnotesize]{subfigure} -% subfigure.sty was written by Steven Douglas Cochran. This package makes it -% easy to put subfigures in your figures. e.g., "Figure 1a and 1b". For IEEE -% work, it is a good idea to load it with the tight package option to reduce -% the amount of white space around the subfigures. subfigure.sty is already -% installed on most LaTeX systems. The latest version and documentation can -% be obtained at: -% http://www.ctan.org/tex-archive/obsolete/macros/latex/contrib/subfigure/ -% subfigure.sty has been superceeded by subfig.sty. - - - -%\usepackage[caption=false]{caption} -%\usepackage[font=footnotesize]{subfig} -% subfig.sty, also written by Steven Douglas Cochran, is the modern -% replacement for subfigure.sty. However, subfig.sty requires and -% automatically loads Axel Sommerfeldt's caption.sty which will override -% IEEEtran.cls handling of captions and this will result in nonIEEE style -% figure/table captions. To prevent this problem, be sure and preload -% caption.sty with its "caption=false" package option. This is will preserve -% IEEEtran.cls handing of captions. Version 1.3 (2005/06/28) and later -% (recommended due to many improvements over 1.2) of subfig.sty supports -% the caption=false option directly: -%\usepackage[caption=false,font=footnotesize]{subfig} -% -% The latest version and documentation can be obtained at: -% http://www.ctan.org/tex-archive/macros/latex/contrib/subfig/ -% The latest version and documentation of caption.sty can be obtained at: -% http://www.ctan.org/tex-archive/macros/latex/contrib/caption/ - - - - -% *** FLOAT PACKAGES *** -% -%\usepackage{fixltx2e} -% fixltx2e, the successor to the earlier fix2col.sty, was written by -% Frank Mittelbach and David Carlisle. This package corrects a few problems -% in the LaTeX2e kernel, the most notable of which is that in current -% LaTeX2e releases, the ordering of single and double column floats is not -% guaranteed to be preserved. Thus, an unpatched LaTeX2e can allow a -% single column figure to be placed prior to an earlier double column -% figure. The latest version and documentation can be found at: -% http://www.ctan.org/tex-archive/macros/latex/base/ - - - -%\usepackage{stfloats} -% stfloats.sty was written by Sigitas Tolusis. This package gives LaTeX2e -% the ability to do double column floats at the bottom of the page as well -% as the top. (e.g., "\begin{figure*}[!b]" is not normally possible in -% LaTeX2e). It also provides a command: -%\fnbelowfloat -% to enable the placement of footnotes below bottom floats (the standard -% LaTeX2e kernel puts them above bottom floats). This is an invasive package -% which rewrites many portions of the LaTeX2e float routines. It may not work -% with other packages that modify the LaTeX2e float routines. The latest -% version and documentation can be obtained at: -% http://www.ctan.org/tex-archive/macros/latex/contrib/sttools/ -% Documentation is contained in the stfloats.sty comments as well as in the -% presfull.pdf file. Do not use the stfloats baselinefloat ability as IEEE -% does not allow \baselineskip to stretch. Authors submitting work to the -% IEEE should note that IEEE rarely uses double column equations and -% that authors should try to avoid such use. Do not be tempted to use the -% cuted.sty or midfloat.sty packages (also by Sigitas Tolusis) as IEEE does -% not format its papers in such ways. - - -%\ifCLASSOPTIONcaptionsoff -% \usepackage[nomarkers]{endfloat} -% \let\MYoriglatexcaption\caption -% \renewcommand{\caption}[2][\relax]{\MYoriglatexcaption[#2]{#2}} -%\fi -% endfloat.sty was written by James Darrell McCauley and Jeff Goldberg. -% This package may be useful when used in conjunction with IEEEtran.cls' -% captionsoff option. Some IEEE journals/societies require that submissions -% have lists of figures/tables at the end of the paper and that -% figures/tables without any captions are placed on a page by themselves at -% the end of the document. If needed, the draftcls IEEEtran class option or -% \CLASSINPUTbaselinestretch interface can be used to increase the line -% spacing as well. Be sure and use the nomarkers option of endfloat to -% prevent endfloat from "marking" where the figures would have been placed -% in the text. The two hack lines of code above are a slight modification of -% that suggested by in the endfloat docs (section 8.3.1) to ensure that -% the full captions always appear in the list of figures/tables - even if -% the user used the short optional argument of \caption[]{}. -% IEEE papers do not typically make use of \caption[]'s optional argument, -% so this should not be an issue. A similar trick can be used to disable -% captions of packages such as subfig.sty that lack options to turn off -% the subcaptions: -% For subfig.sty: -% \let\MYorigsubfloat\subfloat -% \renewcommand{\subfloat}[2][\relax]{\MYorigsubfloat[]{#2}} -% For subfigure.sty: -% \let\MYorigsubfigure\subfigure -% \renewcommand{\subfigure}[2][\relax]{\MYorigsubfigure[]{#2}} -% However, the above trick will not work if both optional arguments of -% the \subfloat/subfig command are used. Furthermore, there needs to be a -% description of each subfigure *somewhere* and endfloat does not add -% subfigure captions to its list of figures. Thus, the best approach is to -% avoid the use of subfigure captions (many IEEE journals avoid them anyway) -% and instead reference/explain all the subfigures within the main caption. -% The latest version of endfloat.sty and its documentation can obtained at: -% http://www.ctan.org/tex-archive/macros/latex/contrib/endfloat/ -% -% The IEEEtran \ifCLASSOPTIONcaptionsoff conditional can also be used -% later in the document, say, to conditionally put the References on a -% page by themselves. - - - - - -% *** PDF, URL AND HYPERLINK PACKAGES *** -% -%\usepackage{url} -% url.sty was written by Donald Arseneau. It provides better support for -% handling and breaking URLs. url.sty is already installed on most LaTeX -% systems. The latest version can be obtained at: -% http://www.ctan.org/tex-archive/macros/latex/contrib/misc/ -% Read the url.sty source comments for usage information. Basically, -% \url{my_url_here}. - - - - - -% *** Do not adjust lengths that control margins, column widths, etc. *** -% *** Do not use packages that alter fonts (such as pslatex). *** -% There should be no need to do such things with IEEEtran.cls V1.6 and later. -% (Unless specifically asked to do so by the journal or conference you plan -% to submit to, of course. ) - +\usepackage{subfig} +\usepackage{color} +\usepackage{graphicx} % correct bad hyphenation here \hyphenation{op-tical net-works semi-conduc-tor} @@ -340,91 +23,24 @@ % was not built to handle multiple paragraphs % -\author{Jean-Fran\c cois Couchot, Raphael Couturier, and Christophe Guyeux*} - -\IEEEauthorblockA{FEMTO-ST Institute, UMR 6174 CNRS\\ -Computer Science Laboratory DISC\\ -University of Franche-Comt\'{e}\\ -Besan\c con, France\\ -\{jean-francois.couchot,raphael.couturier, christophe.guyeux\}@femto-st.fr}\\ +\author{Jean-Fran\c cois Couchot, Raphael Couturier, and Christophe Guyeux* + FEMTO-ST Institute, UMR 6174 CNRS\\ + Computer Science Laboratory DISC\\ + University of Franche-Comt\'{e}\\ + Besan\c con, France\\ + \{jean-francois.couchot,raphael.couturier, christophe.guyeux\}@femto-st.fr\\ * Authors in alphabetic order\\ } - - - -% \author{Michael~Shell,~\IEEEmembership{Member,~IEEE,} -% John~Doe,~\IEEEmembership{Fellow,~OSA,} -% and~Jane~Doe,~\IEEEmembership{Life~Fellow,~IEEE}% <-this % stops a space -% \thanks{M. Shell is with the Department -% of Electrical and Computer Engineering, Georgia Institute of Technology, Atlanta, -% GA, 30332 USA e-mail: (see http://www.michaelshell.org/contact.html).}% <-this % stops a space -% \thanks{J. Doe and J. Doe are with Anonymous University.}% <-this % stops a space -% \thanks{Manuscript received April 19, 2005; revised January 11, 2007.}} - -% note the % following the last \IEEEmembership and also \thanks - -% these prevent an unwanted space from occurring between the last author name -% and the end of the author line. i.e., if you had this: -% -% \author{....lastname \thanks{...} \thanks{...} } -% ^------------^------------^----Do not want these spaces! -% -% a space would be appended to the last name and could cause every name on that -% line to be shifted left slightly. This is one of those "LaTeX things". For -% instance, "\textbf{A} \textbf{B}" will typeset as "A B" not "AB". To get -% "AB" then you have to do: "\textbf{A}\textbf{B}" -% \thanks is no different in this regard, so shield the last } of each \thanks -% that ends a line with a % and do not let a space in before the next \thanks. -% Spaces after \IEEEmembership other than the last one are OK (and needed) as -% you are supposed to have spaces between the names. For what it is worth, -% this is a minor point as most people would not even notice if the said evil -% space somehow managed to creep in. - - - -% The paper headers -%\markboth{Journal of \LaTeX\ Class Files,~Vol.~6, No.~1, January~2007}% -%{Shell \MakeLowercase{\textit{et al.}}: Bare Demo of IEEEtran.cls for Journals} -% The only time the second header will appear is for the odd numbered pages -% after the title page when using the twoside option. -% -% *** Note that you probably will NOT want to include the author's *** -% *** name in the headers of peer review papers. *** -% You can use \ifCLASSOPTIONpeerreview for conditional compilation here if -% you desire. - - - - -% If you want to put a publisher's ID mark on the page you can do it like -% this: -%\IEEEpubid{0000--0000/00\$00.00~\copyright~2007 IEEE} -% Remember, if you use this you must call \IEEEpubidadjcol in the second -% column for its text to clear the IEEEpubid mark. - - - -% use for special paper notices -%\IEEEspecialpapernotice{(Invited Paper)} - - - - +\newcommand{\JFC}[1]{\begin{color}{green}\textit{#1}\end{color}} % make the title area -\maketitle +%\maketitle \begin{abstract} %\boldmath The abstract goes here. \end{abstract} -% IEEEtran.cls defaults to using nonbold math in the Abstract. -% This preserves the distinction between vectors and scalars. However, -% if the journal you are submitting to favors bold math in the abstract, -% then you can use LaTeX's standard command \boldmath at the very start -% of the abstract to achieve this. Many IEEE journals frown on math -% in the abstract anyway. - -% Note that keywords are not normally used for peerreview papers. + \begin{IEEEkeywords} %IEEEtran, journal, \LaTeX, paper, template. Steganography, least-significant-bit (LSB)-based steganography, edge detection, Canny filter, security, syndrome treillis code. @@ -434,26 +50,18 @@ Steganography, least-significant-bit (LSB)-based steganography, edge detection, - -% For peer review papers, you can put extra information on the cover -% page as needed: -% \ifCLASSOPTIONpeerreview -% \begin{center} \bfseries EDICS Category: 3-BBND \end{center} -% \fi -% -% For peerreview papers, this IEEEtran command inserts a page break and -% creates the second title. It will be ignored for other modes. \IEEEpeerreviewmaketitle \section{Introduction} - +\input{intro.tex} \section{Analysis of Steganographic Approaches} +\input{analysis.tex} This work considers digital images as covers and fondation is -spatial least_significant-bit (LSB) replacement. +spatial least significant-bit (LSB) replacement. I this data hiding scheme a subset of all the LSB of the cover image is modified with a secret bit stream depending on to a key, the cover, and the message to embed. This well studied steganographic approach never decreases (resp. increases) @@ -473,15 +81,17 @@ security need : message has to be encrypted before beeing introduced. Using effi LSBR: to coarse (apply hugo breaker on it) \section{Our Approach} -Image Quality: Edge Image Steganography +\input{ourapproach.tex} -Security aspect: -BBS-based cprotographic version of the message +% Image Quality: Edge Image Steganography -Enlarging embeding efficiency: -Syndrome treillis code +% Security aspect: +% BBS-based cprotographic version of the message +% Enlarging embeding efficiency: +% Syndrome treillis code +\input{stc.tex} \section{Conclusion} The conclusion goes here. diff --git a/ourapproach.tex b/ourapproach.tex index 5fc4f7e..2bf476f 100644 --- a/ourapproach.tex +++ b/ourapproach.tex @@ -10,7 +10,8 @@ and inside the extraction one(Fig.~\ref{fig:sch:ext}). \subfloat[Data Embedding.]{ \begin{minipage}{0.49\textwidth} \begin{center} - \includegraphics[width=5cm]{emb.pdf} +% \includegraphics[width=5cm]{emb.pdf} + \includegraphics[width=5cm]{emb.ps} \end{center} \end{minipage} \label{fig:sch:emb} @@ -18,7 +19,8 @@ and inside the extraction one(Fig.~\ref{fig:sch:ext}). \subfloat[Data Extraction.]{ \begin{minipage}{0.49\textwidth} \begin{center} - \includegraphics[width=5cm]{rec.pdf} +% \includegraphics[width=5cm]{rec.pdf} + \includegraphics[width=5cm]{rec.ps} \end{center} \end{minipage} \label{fig:sch:ext} diff --git a/stc/exp/raphus/attaque.py b/stc/exp/raphus/attaque.py new file mode 100755 index 0000000..b3403c4 --- /dev/null +++ b/stc/exp/raphus/attaque.py @@ -0,0 +1,213 @@ +#-*- coding:utf-8 -*- +from os import system +import Image as Im +import ImageEnhance +import PythonMagick as pm +import numpy as np +from ConfigParser import ConfigParser +from random import * +class Attaque: + + @staticmethod + def _commun_in(mat): + (l,h)=mat.shape + at = Im.new("L",(l,h)) + at.putdata(mat.flatten()) + return (l,h,at) + + @staticmethod + def _commun_out(at): + (l,h)=at.size + return np.array(at.getdata()).reshape((l,h)) + + + @staticmethod + def rotation(mat,angle, nombre): + (l,h,at) = Attaque._commun_in(mat) + for k in range(nombre): + carreNoir=Im.new('L',(l*3,h*3),color=1) + carreNoir.paste(at,(l+1,h+1)) + tourne = carreNoir.rotate(angle) + carreNoir = tourne.rotate(-angle) + carreNoir = carreNoir.crop((l+1,h+1,2*l+1,2*h+1)) + #carreNoir = carreNoir.crop((l+1,h+1,2*l+1,2*h+1)) + + return Attaque._commun_out(carreNoir) + + + @staticmethod + def jpeg(mat,nom_temp,taux = 100): + '''Attaque par compression jpeg : + - taux = 100 : image d'origine, + - taux 75 : compression par défaut, + - taux = 1 : le plus fort taux de compression.''' + (l,h,at) = Attaque._commun_in(mat) + ch = nom_temp+'_'+str(taux)+'.jpg' + #TODO : utiliser le module de fichier temporaire de python + at.save(ch,quality = taux) + at = Im.open(ch) + #system('rm '+ch) + return Attaque._commun_out(at) + + + @staticmethod + def jp2(mat,nom_temp,taux = 100): + '''Attaque par compression jpeg : + - taux = 100 : image d'origine, + - taux 75 : compression par défaut, + - taux = 1 : le plus fort taux de compression.''' + (l,h,at) = Attaque._commun_in(mat) + at.save("img.bmp") + img_2_nm = "img_"+str(taux)+"_.jp2" + + st = "convert img.bmp -define jp2:rate="+\ + str(taux/float(100))+" "+img_2_nm + print st + system(st) + system("convert "+img_2_nm+" img_2.png") + atb = Im.open("img_2.png") + return Attaque._commun_out(atb) + + + @staticmethod + def decoupage(mat, taille = 50, position = (0,0)): + ''' + Attaque par découpage de l'image. + ''' + (_,_,at) = Attaque._commun_in(mat) + ch = '5007_dec_'+str(taille)+'.png' + if taille > 0 : + carreNoir=Im.new('L',(taille,taille)) + carreNoir.putdata([0 for _ in range(taille**2)]) + at.paste(carreNoir,position) +# at.save(ch) + return Attaque._commun_out(at) + + + @staticmethod + def redimensionnement(mat, facteur, nombre = 1): + ''' + Attaque par redimensionnement de l'image. + ''' + (l,h,at) = Attaque._commun_in(mat) + for k in range(nombre): + atb = at.resize((int(l*facteur), int(h*facteur))) + atc = atb.resize((l,h)) + return Attaque._commun_out(atc) + + @staticmethod + def flou(mat,taux = 1): + + ''' + Attaque en jouant sur le flou/la netteté : + - taux = 1 : image d'origine, + - taux < 1 : image plus floue, + - taux > 1 : image plus nette. + ''' + (_,_,at) = Attaque._commun_in(mat) + ch = '5007_flou_'+str(taux)+'.png' + amelioration = ImageEnhance.Sharpness(at) + atb = amelioration.enhance(taux) +# atb.save(ch) + return Attaque._commun_out(atb) + + + @staticmethod + def contraste(mat,taux = 1): + ch = '5007_contrast_'+str(taux)+'.png' + + ''' + Attaque en jouant sur le flou/la netteté : + - taux = 1 : image d'origine, + - taux < 1 : image plus contrastée, + - taux > 1 : image plus nette. + ''' + (_,_,at) = Attaque._commun_in(mat) + amelioration = ImageEnhance.Contrast(at) + atb = amelioration.enhance(taux) +# atb.save(ch) + return Attaque._commun_out(atb) + + + + + @staticmethod + def allea_dwt(mat): + """ choisit une des 6 attaques au hasard avec paramètre cohérents au + hasard + """ + nb_at = 6 + choix = randint(0,5) + if choix == 0: + return Attaque.rotation(mat,30*random(), 1) + if choix == 1: + return Attaque.jp2(mat,"alea",int(100*random())) + if choix == 2: + return Attaque.decoupage(mat, 50, (0,0)) + if choix == 3: + return Attaque.redimensionnement(mat, 0.75*randint(1,2),1) + if choix == 4: + return Attaque.flou(mat, 0.70+.6*random()) + if choix == 5: + return Attaque.contraste(mat,0.70+.6*random()) + + @staticmethod + def enfloat(mat): + (l,c)=mat.shape + r=np.zeros((l,c)) + for i in range(l): + for j in range(c) : + r[i][j]=float(mat[i][j]) + return r + + + @staticmethod + def allea_dct(mat): + """ choisit une des 6 attaques au hasard avec paramètre cohérents au + hasard + """ + r=None + nb_at = 6 + choix = randint(0,6) + if choix == 0: + r=Attaque.rotation(mat,30*random(), 1) + if choix == 1: + r=Attaque.jp2(mat,"alea",int(100*random())) + if choix == 2: + r=Attaque.decoupage(mat, 50, (0,0)) + if choix == 3: + r=Attaque.redimensionnement(mat, 0.75*randint(1,2),1) + if choix == 4: + r=Attaque.flou(mat, 0.70+.6*random()) + if choix == 5: + r=Attaque.contraste(mat,0.70+.6*random()) + if choix == 6: + r=Attaque.jpeg(mat,"alea",int(100*random())) + + rp = Attaque.enfloat(r) + return rp + + + """ + def bruitGaussien(self, ecarttype): + ''' + Ajoute un bruit gaussien. + ''' + for x in range(self._image.size[0]): + for y in range(self._image.size[1]): + self._image.putpixel((x,y), + int(random.normal(self._image.getpixel((x,y)), ecarttype))) + + + def bruitUniforme(self, ecart): + ''' + Ajoute un bruit uniforme. + ''' + for x in range(self._image.size[0]): + for y in range(self._image.size[1]): + self._image.putpixel((x,y), + self._image.getpixel((x,y)) + \ + int(random.uniform(-ecart,ecart))) + + + """ diff --git a/stc/exp/raphus/attaques.py b/stc/exp/raphus/attaques.py new file mode 100644 index 0000000..52fde83 --- /dev/null +++ b/stc/exp/raphus/attaques.py @@ -0,0 +1,369 @@ +#-*-coding:utf-8-*- + +############################################# +# Script réalisé dans le cadre du papier +# concernant l'utilisation de plusieurs +# fonctions chaotiques (pas seulement la +# négation vectorielle) pour le tatouage. +# +# On utilise 3 fonctions différentes, on tatoue +# dans le domaine ondelette. +############################################# +import pywt + +from numpy import * + +#from outilsBase import conversion, getBit, setBit +from random import * +from copy import deepcopy +import Image as im +from ImageChops import difference +from suite import * +from attaque import Attaque + +def matrice_to_bits(matrice): + ''' + Renvoie la matrice des écritures binaires de matrice. + Les coefficients floants deviennent des chaînes (str) de bits. + ''' + (m,n) = matrice.shape + retour = [] + for l in range(m): + ligne = [] + for c in range(n): + ligne.append(conversion(str(matrice[l,c]),2)) + retour.append(ligne) + return retour + + + +def matrice_lscs(matrice,lscs): + ''' + Matrice est une liste de listes, lscs est une liste. + + A partir d'une matrice de coefficients binaires, vus comme + des chaines de caractères, extrait les bits dont les positions + sont données par la liste lscs. + + Dans la liste lscs, un entier positif signifie devant la virgule, + un entier négatif signifie derrière. Le premier bit devant la + virgule est le bit 1, le premier bit derrière la virgule est le -1. + + Le retour est une liste de bits (entiers). + ''' + m,n = len(matrice), len(matrice[0]) + retour = [] + for l in range(m): + for c in range(n): + #num = str(round(float(matrice[l][c]),2)) + num = matrice[l][c] + + if '.' not in num: + ent,dec = num.replace('-',''),'0' + else: + ent,dec = num.replace('-','').split('.') + ent,dec = list(ent),list(dec) + ent.reverse() + for lsc in lscs: + if lsc > 0 and len(ent)>=lsc: + retour.append(ent[lsc-1]) + elif lsc<0 and len(dec)>=abs(lsc): + retour.append(dec[abs(lsc)-1]) + else: + retour.append('0') + return [int(k) for k in retour][:-3] + + +def embarque(liste,matrice,lscs): + m,n = len(matrice), len(matrice[0]) + retour = [] + cpt = 0 + for l in range(m): + for c in range(n): + if '-' in matrice[l][c]: + signe = '-' + else: + signe = '' + if '.' not in matrice[l][c]: + ent,dec = matrice[l][c].replace('-',''),'0' + else: + ent,dec = matrice[l][c].replace('-','').split('.') + ent,dec = list(ent),list(dec) + ent.reverse() + maximum = max([abs(k) for k in lscs]) + ent = list(''.join(ent).zfill(maximum+2)) + dec = list(''.join(dec).zfill(maximum+2)) + print dec + for lsc in lscs: + if lsc > 0: + ent[lsc-1] = str(liste[cpt]) + else: + dec[abs(lsc)-1] = str(liste[cpt]) + cpt += 1 + ent.reverse() + ent = ''.join(ent) + dec = ''.join(dec) + print ent+'.'+dec + + + +def f(L): + assert len(L)%4 == 1 + n = len(L)/4 + retour = [int(not L[k]) for k in range(n)] + retour.extend([L[k-n] for k in range(n,2*n)]) + retour.extend([int(L[k-2*n])*int(not L[k+1]) for k in range(2*n,4*n)]) + retour.extend([int(not L[2*n])]) + return retour + + + + +def f(L): + retour = [int(not L[0])] + retour.extend([L[k-1] for k in range(1,len(L))]) + return retour + + + + +def f(x): + rl=[] + k = 1 + for el in x: + if k%2 != 0 : + rl.append(int(not el)) + else: + rl.append(0 if sum(x[k-2:k])%2==0 else 1 ) + k+=1 + return rl + + + + +def f(i,x): + r = 0 + if i%2 == 0 : + r = int(not x[i]) + else: + r = 0 if sum(x[i-1:i+1])%2==0 else 1 + return r + + + +def f(i,L): + return int(not L[i]) + + + +def embarque2(liste,matrice,lscs): + + m,n = len(matrice), len(matrice[0]) + retour = deepcopy(matrice) + cpt = 0 + for l in range(m): + for c in range(n): + for lsc in lscs: + try: + retour[l,c] = setBit(str(retour[l,c]),lsc, liste[cpt]) + cpt += 1 + except: + pass + return retour + +def PSNR(mat1,mat2): + (li,co) = mat1.shape + ''' + Retourne le PSNR entre deux images. + ''' + from math import log + densite = 2**8-1 + eqm = 0 + for k in range(li): + for l in range(co): + eqm+=(mat1[k][l] - mat2[k][l])**2 + r= float(eqm)/li/co + if r !=0: + return 10*log(densite**2/r,10) + else: + return "Infini" + + + +def diff(mat1,mat2): + lm=len(mat1) + cpt = 0 + for k in range(lm): + if mat1[k] != mat2[k] : + cpt +=1 + #print mat1[k],mat2[k] + return float(100)*cpt/lm + +def arrondi_en_entier(mat): + (l,c) = mat.shape + return array([[round(mat[i][j]) for j in range(c)]for i in range(l)]) + + + + + +def experience(nom_fichier): + str_acc = "nom;"+nom_fichier + + initiale_image = im.open(nom_fichier+".png") + (taillex,tailley) = initiale_image.size + initiale_matrice = array(initiale_image.getdata()).reshape((taillex,tailley)) + + #recup + hote_dct = Dct(nom_fichier+".png",idx_dct) + hote_dct2 = Dct(nom_fichier+".png",idx_dct) + + initiale_dct= deepcopy(hote_dct.get_ext_dct()) + + + # recup bits insignifiants + initiale_lscs = matrice_lscs(matrice_to_bits(initiale_dct),LSCs) + initiale_lscs_a_iterer = deepcopy(initiale_lscs) + + # Nb LSCs + lm = len(initiale_lscs) + # Itérations D2 + ciis = CIIS(random(),random(),random()/2,lm-1,lm)._genere() + for k in range(4*lm): + strat = ciis.next() + #print strat + initiale_lscs_a_iterer[strat] = int( + f(strat,initiale_lscs_a_iterer)) + + + + # Calcul du nombre de différences dans la matrice DCT + + + str_acc += ";#lscs;" + str(lm) + + + dif_iter = diff(initiale_lscs,initiale_lscs_a_iterer) + str_acc += ";#diff it ; " + str(dif_iter) + + + # Tatouage de la matrice") + marquee_ext_dct = embarque2(initiale_lscs_a_iterer, + initiale_dct,LSCs) + + # reconstruction de la matrice complete + hote_dct2.set_ext_dct(marquee_ext_dct) + marquee_matrice = hote_dct2._matrice + marquee_matrice = arrondi_en_entier(marquee_matrice) + + + #sauvegarde de l'image + (l,h)=marquee_matrice.shape + at = im.new("L",(l,h)) + at.putdata(marquee_matrice.flatten()) + at.save(nom_fichier+"_bis.png") + at.show() + + +#listing = os.listdir(path_cover) + + + + # psnr + str_acc += ";PSNR;" + str(PSNR(initiale_matrice,marquee_matrice)) + + + nbexp=10 + # matrices attaquees par rotation + attaquee_matrice = [] + print "rotations" + for k in range(nbexp): + at = Attaque.rotation(marquee_matrice, + 3*(k+1), + 1) + attaquee_matrice += [at] + + # matrices attaquees compression jpeg + print "compression" + for k in range(nbexp): + at = Attaque.jpeg(marquee_matrice, + nom_fichier, + 100-3*(k+1)) + attaquee_matrice += [at] + + + # matrices attaquees compression jp2000 + print "compression jp2000" + for k in range(nbexp): + at = Attaque.jp2(marquee_matrice, + nom_fichier, + 100-10*(k+1)) + attaquee_matrice += [at] + + + + print "decoupage" + # matrices attaquees decoupage + for k in range(nbexp): + t = int(0.1*(k+1)*min(taillex,tailley)) + at = Attaque.decoupage(marquee_matrice, + t, + (0,0)) + attaquee_matrice += [at] + + print "flou" + # matrices attaquees flou + for k in range(nbexp): + t=0.6+0.08*(k+1) + at = Attaque.flou(marquee_matrice,t) + attaquee_matrice += [at] + + print "contraste" + # matrices attaquees contrast + for k in range(nbexp): + t=0.6+0.08*(k+1) + at = Attaque.contraste(marquee_matrice,t) + attaquee_matrice += [at] + + + # matrices attaquees redimensionnement + print "dimensionnement" + attaquee_matrice += [Attaque.redimensionnement(marquee_matrice, + 0.75, + 1)] + attaquee_matrice += [Attaque.redimensionnement(marquee_matrice, + 1.5, + 1)] + + + + + print "nombre d'attaques",len(attaquee_matrice) + + # evaluation des attaques + _,(marquee_H2,marquee_V2,marquee),(_,_,_) = \ + pywt.wavedec2(marquee_matrice, + 'db1', + level = 2) + marquee_lscs = matrice_lscs(matrice_to_bits(marquee_matrice),LSCs) + + c=0 + for am in attaquee_matrice: + c +=1 + attaquee = am + + attaquee_lscs = matrice_lscs(matrice_to_bits(attaquee),LSCs) + d = diff(marquee_lscs,attaquee_lscs) + str_acc += ";" + str(d) + + + + return str_acc + + +""" +for j in sample(range(1,3001),2): + print experience("../images/"+str(j),3) + +""" +print experience("../images/"+str(3622),3) diff --git a/stc/exp/raphus/script_attaques.py b/stc/exp/raphus/script_attaques.py new file mode 100644 index 0000000..1e7d873 --- /dev/null +++ b/stc/exp/raphus/script_attaques.py @@ -0,0 +1,444 @@ +#-*-coding:utf-8-*- + +############################################# +# Script réalisé dans le cadre du papier +# concernant l'utilisation de plusieurs +# fonctions chaotiques (pas seulement la +# négation vectorielle) pour le tatouage. +# +# On utilise 3 fonctions différentes, on tatoue +# dans le domaine ondelette. +############################################# + +from numpy import * +from sobel555_for_ensemble import * +from bbs import * + +#from outilsBase import conversion, getBit, setBit +from random import * +from copy import deepcopy +import Image as im +from ImageChops import difference +from attaque import Attaque + +def matrice_to_bits(matrice): + ''' + Renvoie la matrice des écritures binaires de matrice. + Les coefficients floants deviennent des chaînes (str) de bits. + ''' + (m,n) = matrice.shape + retour = [] + for l in range(m): + ligne = [] + for c in range(n): + ligne.append(conversion(str(matrice[l,c]),2)) + retour.append(ligne) + return retour + + + +def matrice_lscs(matrice,lscs): + ''' + Matrice est une liste de listes, lscs est une liste. + + A partir d'une matrice de coefficients binaires, vus comme + des chaines de caractères, extrait les bits dont les positions + sont données par la liste lscs. + + Dans la liste lscs, un entier positif signifie devant la virgule, + un entier négatif signifie derrière. Le premier bit devant la + virgule est le bit 1, le premier bit derrière la virgule est le -1. + + Le retour est une liste de bits (entiers). + ''' + m,n = len(matrice), len(matrice[0]) + retour = [] + for l in range(m): + for c in range(n): + #num = str(round(float(matrice[l][c]),2)) + num = matrice[l][c] + + if '.' not in num: + ent,dec = num.replace('-',''),'0' + else: + ent,dec = num.replace('-','').split('.') + ent,dec = list(ent),list(dec) + ent.reverse() + for lsc in lscs: + if lsc > 0 and len(ent)>=lsc: + retour.append(ent[lsc-1]) + elif lsc<0 and len(dec)>=abs(lsc): + retour.append(dec[abs(lsc)-1]) + else: + retour.append('0') + return [int(k) for k in retour][:-3] + + +def embarque(liste,matrice,lscs): + m,n = len(matrice), len(matrice[0]) + retour = [] + cpt = 0 + for l in range(m): + for c in range(n): + if '-' in matrice[l][c]: + signe = '-' + else: + signe = '' + if '.' not in matrice[l][c]: + ent,dec = matrice[l][c].replace('-',''),'0' + else: + ent,dec = matrice[l][c].replace('-','').split('.') + ent,dec = list(ent),list(dec) + ent.reverse() + maximum = max([abs(k) for k in lscs]) + ent = list(''.join(ent).zfill(maximum+2)) + dec = list(''.join(dec).zfill(maximum+2)) + print dec + for lsc in lscs: + if lsc > 0: + ent[lsc-1] = str(liste[cpt]) + else: + dec[abs(lsc)-1] = str(liste[cpt]) + cpt += 1 + ent.reverse() + ent = ''.join(ent) + dec = ''.join(dec) + print ent+'.'+dec + + + +def f(L): + assert len(L)%4 == 1 + n = len(L)/4 + retour = [int(not L[k]) for k in range(n)] + retour.extend([L[k-n] for k in range(n,2*n)]) + retour.extend([int(L[k-2*n])*int(not L[k+1]) for k in range(2*n,4*n)]) + retour.extend([int(not L[2*n])]) + return retour + + + + +def f(L): + retour = [int(not L[0])] + retour.extend([L[k-1] for k in range(1,len(L))]) + return retour + + + + +def f(x): + rl=[] + k = 1 + for el in x: + if k%2 != 0 : + rl.append(int(not el)) + else: + rl.append(0 if sum(x[k-2:k])%2==0 else 1 ) + k+=1 + return rl + + + + +def f(i,x): + r = 0 + if i%2 == 0 : + r = int(not x[i]) + else: + r = 0 if sum(x[i-1:i+1])%2==0 else 1 + return r + + + +def f(i,L): + return int(not L[i]) + + + +def embarque2(liste,matrice,lscs): + + m,n = len(matrice), len(matrice[0]) + retour = deepcopy(matrice) + cpt = 0 + for l in range(m): + for c in range(n): + for lsc in lscs: + try: + retour[l,c] = setBit(str(retour[l,c]),lsc, liste[cpt]) + cpt += 1 + except: + pass + return retour + +def PSNR(mat1,mat2): + (li,co) = mat1.shape + ''' + Retourne le PSNR entre deux images. + ''' + from math import log + densite = 2**8-1 + eqm = 0 + for k in range(li): + for l in range(co): + eqm+=(mat1[k][l] - mat2[k][l])**2 + r= float(eqm)/li/co + if r !=0: + return 10*log(densite**2/r,10) + else: + return "Infini" + + + +def diff(mat1,mat2): + lm=len(mat1) + cpt = 0 + for k in range(lm): + if mat1[k] != mat2[k] : + cpt +=1 + #print mat1[k],mat2[k] + return float(100)*cpt/lm + +def arrondi_en_entier(mat): + (l,c) = mat.shape + return array([[round(mat[i][j]) for j in range(c)]for i in range(l)]) + + + + +def sauve(data,outfile="dummy.png",file_msg="invader.png"): + (l,h)=im.open(file_msg).size + outIm = im.new('L',im.open(file_msg).size) + queue = [255 if x != 0 else 0 for x in data] + queue = queue[len(queue)-l*h:] + outIm.putdata(queue) + outIm.save("apresattaque.png") + + + + +def retrouve_message_parametre(file_msg="invader.png"): + + bbs = BlumBlumShub(); + bbs.setN(M) + bbs.setSeed(X) + + message = [] + for c in [x if x==0 else 1 for x in im.open(file_msg).getdata()]: + message +=[c] + + leng_msg=len(message) + leng='%08d'%len(message) + len_leng=len(leng) + leng_error=int(len_leng) + leng_cor=leng + List_pack=a2b_list(leng_cor) + List_pack += message + #print List_pack + leng_msg=len(List_pack) + + List_random=[] + while len(List_random)= 2 + index = min(int(alpha),9) + H_hat2 = { + 2 : [71,109], + 3 : [95, 101, 121], + 4 : [81, 95, 107, 121], + 5 : [75, 95, 97, 105, 117], + 6 : [73, 83, 95, 103, 109, 123], + 7 : [69, 77, 93, 107, 111, 115, 121], + 8 : [69, 79, 81, 89, 93, 99, 107, 119], + 9 : [69, 79, 81, 89, 93, 99, 107, 119, 125] + }[index] + + + + Stc_message2=[getBit(level2[l],bit_to_read) for l in List_bit_to_change2] + LL2=list(List_bit_to_change2) + + print "Level",max([level2[l]-level[l] for l in xrange(len(Stc_message2))]) + #print "List bit to change",max([LL2[l]-LL1[l] for l in xrange(len(Stc_message2))]) + #print "Stc message", max([Stc_message[l]-Stc_message2[l] for l in xrange(len(Stc_message))]) + + Message2 = [x%2 for x in prod(H_hat2,len(Message),Stc_message2)] + + print "Message final",Message2 + #print equiv(Message,Message2) + + #print "fini" + + l=0 + val_mod2=0 + list_msg=[] + decoded_msg="" + + MessageDecoded2=[(int(Message2[l])^int(List_random[l])) for l in xrange(len(Message2))] +# print conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(leng_error*8)])) +# print int(conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(leng_error*8)]))) + + #print "MessageDecoded2",MessageDecoded2 + #print conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(len(Message2))])) + + + sauve(MessageDecoded2) + + return MessageDecoded2 + + + + + + +def main(): + path_stego = '/home/couchot/rech/CCG12/canny/stc/exp/raphus/stego/' + path_cover = '/home/couchot/rech/BCG10/Oxford11/experiments/images/' + list_nb_bit=[] + l=0 + listing = [957, 108, 106, 29, 431, 924, 262, 477, 346, 809] + listing = [809] + (leng_msg,Message,List_random) = retrouve_message_parametre() + print "params :", leng_msg,len(Message),List_random[0:5] + for infile in listing: + # if l<10: + fi = path_cover+str(infile)+'.png' + fo = path_stego+str(infile)+'.png' + experience(fo,leng_msg,Message,List_random) + l+=1 + +if __name__ == "__main__": + main() + + + + + + diff --git a/stc/exp/raphus/sobel555_for_ensemble.py b/stc/exp/raphus/sobel555_for_ensemble.py index 89e0cbd..4a31c20 100644 --- a/stc/exp/raphus/sobel555_for_ensemble.py +++ b/stc/exp/raphus/sobel555_for_ensemble.py @@ -429,7 +429,7 @@ def compute_filter_canny(level,image,MsgLen): processed= array(processed.getdata()).flatten() List7=set(compute_list_bit_to_change(100,processed)) - #nb_bit_embedded=(512*512/10)+40 + nb_bit_embedded=max(2*MsgLen,int(len(List3)/MsgLen)*MsgLen) print "nb_bit_embedded",nb_bit_embedded AvailablePixel3=List3 @@ -458,9 +458,9 @@ def compute_filter_canny(level,image,MsgLen): sub = range(len(level2)) - #print "avail P3",len(AvailablePixel3) - #print "avail P5",len(AvailablePixel5) - #print "avail P7",len(AvailablePixel7) + print "avail P3",len(AvailablePixel3) + print "avail P5",len(AvailablePixel5) + print "avail P7",len(AvailablePixel7) Weight=[0 for _ in sub] @@ -489,10 +489,115 @@ def compute_filter_canny(level,image,MsgLen): +def verifie(fileout,leng_msg,Message,): + global M,X + bit_to_read = 1 + dd2 = im.open(fileout) + dd2 = dd2.convert('RGB') + red2, green, blue = dd2.split() + level2=red2.copy() + + [List_bit_to_change2,Weight2]=compute_filter_canny(level2,dd2,leng_msg) + + + level2= array(level2.getdata()).flatten() + + print "support2",len(List_bit_to_change2) + print "message2",len(Message) + print "weight2",len(Weight2) + + alpha = float(len(List_bit_to_change2))/len(Message) + assert alpha >= 2 + index = min(int(alpha),9) + H_hat2 = { + 2 : [71,109], + 3 : [95, 101, 121], + 4 : [81, 95, 107, 121], + 5 : [75, 95, 97, 105, 117], + 6 : [73, 83, 95, 103, 109, 123], + 7 : [69, 77, 93, 107, 111, 115, 121], + 8 : [69, 79, 81, 89, 93, 99, 107, 119], + 9 : [69, 79, 81, 89, 93, 99, 107, 119, 125] + }[index] + + + print H_hat2 + Stc_message2=[getBit(level2[l],bit_to_read) for l in List_bit_to_change2] + LL2=list(List_bit_to_change2) -def mystego(filein, fileout): + """ + print "Level",max([level2[l]-level[l] for l in xrange(len(Stc_message2))]) + print "List bit to change",max([LL2[l]-LL1[l] for l in xrange(len(Stc_message))]) + print "Stc message", max([Stc_message[l]-Stc_message2[l] for l in xrange(len(Stc_message))]) + """ + Message2 = [x%2 for x in prod(H_hat2,len(Message),Stc_message2)] + level2=Message2 + +# print "mesg",Message +# print "mesg2",Message2 + + l=0 + val_mod2=0 + list_msg=[] + decoded_msg="" + + + + bbs = BlumBlumShub(); + bbs.setN(M) + bbs.setSeed(X) + + List_random=[] + while len(List_random)=leng_error*8 and val_mod2= 2 - index = min(int(alpha),9) - H_hat2 = { - 2 : [71,109], - 3 : [95, 101, 121], - 4 : [81, 95, 107, 121], - 5 : [75, 95, 97, 105, 117], - 6 : [73, 83, 95, 103, 109, 123], - 7 : [69, 77, 93, 107, 111, 115, 121], - 8 : [69, 79, 81, 89, 93, 99, 107, 119], - 9 : [69, 79, 81, 89, 93, 99, 107, 119, 125] - }[index] - - - print H_hat,H_hat2 - - - Stc_message2=[getBit(level2[l],bit_to_read) for l in List_bit_to_change2] - LL1=list(List_bit_to_change); - LL2=list(List_bit_to_change2) - - print "Level",max([level2[l]-level[l] for l in xrange(len(Stc_message2))]) - print "List bit to change",max([LL2[l]-LL1[l] for l in xrange(len(Stc_message))]) - print "Stc message", max([Stc_message[l]-Stc_message2[l] for l in xrange(len(Stc_message))]) - - Message2 = [x%2 for x in prod(H_hat2,len(Message),Stc_message2)] - level2=Message2 - -# print "mesg",Message -# print "mesg2",Message2 - - print equiv(Message,Message2) - print "fini" - - l=0 - val_mod2=0 - list_msg=[] - decoded_msg="" - - MessageDecoded2=[(int(Message2[l])^int(List_random[l])) for l in xrange(len(Message2))] -# print conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(leng_error*8)])) -# print int(conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(leng_error*8)]))) - - print "MessageDecoded2",MessageDecoded2 - print conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(len(Message2))])) - - - - - - -# for l in List_bit_to_change2: -# if(val_mod2=leng_error*8 and val_mod2