diff -Nru weplab-0.1.5/debian/changelog weplab-0.1.5/debian/changelog --- weplab-0.1.5/debian/changelog 2016-11-23 06:30:23.000000000 +0000 +++ weplab-0.1.5/debian/changelog 2016-11-22 17:02:32.000000000 +0000 @@ -1,3 +1,28 @@ +weplab (0.1.5-4) unstable; urgency=medium + + * QA upload. + * Bumped DH level to 10. + * Migrations: + - debian/copyright to 1.0 format. + - debian/rules to new (reduced) format. + - DebSrc to 3.0 format. + - Using dh-autoreconf now. + * debian/control: + - Added the ${misc:Depends} variable to Depends field. + - Bumped Standards-Version to 3.9.8. + * debian/copyright: update all data. + * debian/patches/: + - Created the following patches: + ~ 10_fix-headers_and_warnings.patch. + ~ 20_modernize_automake_call.patch. + ~ 30_fix-spellings-final-binary.patch. + ~ 40_fix-spellings-manpage.patch. (Closes: #644652) + * debian/watch: + - Bumped to version 4. + - Improved. + + -- Joao Eriberto Mota Filho Tue, 22 Nov 2016 15:02:32 -0200 + weplab (0.1.5-3) unstable; urgency=medium * QA upload. diff -Nru weplab-0.1.5/debian/compat weplab-0.1.5/debian/compat --- weplab-0.1.5/debian/compat 2016-11-23 06:30:23.000000000 +0000 +++ weplab-0.1.5/debian/compat 2016-11-22 17:02:32.000000000 +0000 @@ -1 +1 @@ -5 +10 diff -Nru weplab-0.1.5/debian/control weplab-0.1.5/debian/control --- weplab-0.1.5/debian/control 2016-11-23 06:30:23.000000000 +0000 +++ weplab-0.1.5/debian/control 2016-11-22 17:02:32.000000000 +0000 @@ -2,13 +2,13 @@ Section: net Priority: optional Maintainer: Debian QA Group -Build-Depends: debhelper (>= 5), autotools-dev, libpcap0.8-dev -Standards-Version: 3.7.2 -Homepage: http://weplab.sourceforge.net/ +Build-Depends: debhelper (>= 10), dh-autoreconf, libpcap0.8-dev +Standards-Version: 3.9.8 +Homepage: http://weplab.sf.net Package: weplab Architecture: any -Depends: ${shlibs:Depends} +Depends: ${misc:Depends}, ${shlibs:Depends} Description: tool designed to break WEP keys WepLab is a tool designed to teach how WEP works, what different vulnerabilities it has, and how they can be used in practice to diff -Nru weplab-0.1.5/debian/copyright weplab-0.1.5/debian/copyright --- weplab-0.1.5/debian/copyright 2016-11-23 06:30:23.000000000 +0000 +++ weplab-0.1.5/debian/copyright 2016-11-22 17:02:32.000000000 +0000 @@ -1,43 +1,39 @@ -This package was debianized by Adam Cécile (Le_Vert) on -Thu, 24 Aug 2006 16:14:52 +0200. +Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ +Upstream-Name: WepLab +Source: http://weplab.sf.net + +Files: * +Copyright: 2004-2005 Jose Ignacio Sanchez Martin +License: GPL-2+ +Comment: Jose Ignacio Sanchez Martin, aka Topo[LB] + +Files: md5.c +Copyright: 1993 Colin Plumb +License: public-domain + +Files: debian/* +Copyright: 2006-2007 Adam Cécile (Le_Vert) + 2015 gregor herrmann + 2016 Joao Eriberto Mota Filho +License: GPL-2+ + +License: GPL-2+ + This package is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + . + This package is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + . + You should have received a copy of the GNU General Public License + along with this program. If not, see + . + On Debian systems, the complete text of the GNU General + Public License version 2 can be found in "/usr/share/common-licenses/GPL-2". -It was downloaded from http://weplab.sourceforge.net/ - -Upstream Author: Jose Ignacio Sanchez - -Copyright: (C) 2004-2005 Jose Ignacio Sanchez Martin - Topo[LB] - -License: - - This package is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - This package is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this package; if not, write to the Free Software - Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - -On Debian systems, the complete text of the GNU General -Public License can be found in `/usr/share/common-licenses/GPL'. - - -The Debian packaging is (C) 2006, Adam Cécile (Le_Vert) -and is licensed under the GPL, see above. - - -"md5.c" is in the public domain. No copyright is claimed. See below :. - - This code has been heavily hacked by Tatu Ylonen to - make it compile on machines like Cray that don't have a 32 bit integer - type. - - This code implements the MD5 message-digest algorithm. - The algorithm is due to Ron Rivest. This code was - written by Colin Plumb in 1993, no copyright is claimed. - This code is in the public domain; do with it what you wish. +License: public-domain + This code is in the public domain; do with it what you wish. diff -Nru weplab-0.1.5/debian/patches/10_fix-headers_and_warnings.patch weplab-0.1.5/debian/patches/10_fix-headers_and_warnings.patch --- weplab-0.1.5/debian/patches/10_fix-headers_and_warnings.patch 1970-01-01 00:00:00.000000000 +0000 +++ weplab-0.1.5/debian/patches/10_fix-headers_and_warnings.patch 2016-11-22 17:02:32.000000000 +0000 @@ -0,0 +1,75 @@ +Description: fix a headers and some warnings. +Author: Joao Eriberto Mota Filho +Last-Update: 2016-11-22 +Index: weplab-0.1.5/md5.c +=================================================================== +--- weplab-0.1.5.orig/md5.c ++++ weplab-0.1.5/md5.c +@@ -19,6 +19,8 @@ + */ + + /* #include "includes.h" */ ++#include ++#include + #include "md5.h" + + /* +Index: weplab-0.1.5/main.c +=================================================================== +--- weplab-0.1.5.orig/main.c ++++ weplab-0.1.5/main.c +@@ -108,7 +108,7 @@ void ShowHelp(void){ + + void QuitParameterError(char *error){ + printf("\n ERROR:"); +- printf(error); ++ printf("error"); + printf("\n\n Maybe you should take a look at the extended options (--help), read the manual (README) or visit the website http://weplab.sourceforge.net\n\n\n"); + exit(1); + } +@@ -157,7 +157,7 @@ int main(int argc, char **argv){ + int optionSelected=1; // 2 words, 3 heuristics, 4 bruteforce + int opt; + int keySize=64; +- int i,j; ++ int i; + int sizeaux; + unsigned char *saux; + int tmp[6]; +Index: weplab-0.1.5/dictionary.c +=================================================================== +--- weplab-0.1.5.orig/dictionary.c ++++ weplab-0.1.5/dictionary.c +@@ -183,8 +183,8 @@ void dictionary (void){ + int totalPackets; + //unsigned char key2[13]="\x3e\x9a\xa0\xa4\xc6\x2e\xad\x59\x5a\x07\xa1\x80\x1f"; + int trues; +- int totalByte=0xFF; +- int totalTemp=0; ++// int totalByte=0xFF; ++// int totalTemp=0; + + #ifdef _DEBUG + debug("Starting Dictionary based cracking."); +Index: weplab-0.1.5/heuristics.c +=================================================================== +--- weplab-0.1.5.orig/heuristics.c ++++ weplab-0.1.5/heuristics.c +@@ -56,7 +56,7 @@ unsigned char ranking[13][MAX_CANDIDATES + + void GuessOutputByte(int keyByte, u_char *sKey, t_StoredPacketsIV *packets, t_storedPacket **controlPackets, unsigned int votes[17][256]) + { +- int i, j,k; ++ int i, j; + unsigned int x; + u_char E, S[N]; + u_char K[13 + 3]; +@@ -69,7 +69,7 @@ void GuessOutputByte(int keyByte, u_char + unsigned int totalIvs=0; + + unsigned int breath=0; +- unsigned char byteBackup=0; ++// unsigned char byteBackup=0; + unsigned int totalVotes=0; + unsigned int totalVotesTmp=0; + diff -Nru weplab-0.1.5/debian/patches/20_modernize_automake_call.patch weplab-0.1.5/debian/patches/20_modernize_automake_call.patch --- weplab-0.1.5/debian/patches/20_modernize_automake_call.patch 1970-01-01 00:00:00.000000000 +0000 +++ weplab-0.1.5/debian/patches/20_modernize_automake_call.patch 2016-11-22 17:02:32.000000000 +0000 @@ -0,0 +1,16 @@ +Description: modernize automake call in configure.ac. +Author: Joao Eriberto Mota Filho +Last-Update: 2016-11-22 +Index: weplab-0.1.5/configure.ac +=================================================================== +--- weplab-0.1.5.orig/configure.ac ++++ weplab-0.1.5/configure.ac +@@ -1,5 +1,6 @@ +-AC_INIT(weplab, 0.1.5, Topo[LB] - Jose Ignacio Sanchez , main) +-AM_INIT_AUTOMAKE(weplab, 0.1.5) ++AC_INIT([weplab], [0.1.5], [TopoLB - Jose Ignacio Sanchez ]) ++AC_CONFIG_SRCDIR([attack.c]) ++AM_INIT_AUTOMAKE + AC_PROG_CC + AC_PROG_INSTALL + #AC_CONFIG_FILES([Makefile]) diff -Nru weplab-0.1.5/debian/patches/30_fix-spellings-final-binary.patch weplab-0.1.5/debian/patches/30_fix-spellings-final-binary.patch --- weplab-0.1.5/debian/patches/30_fix-spellings-final-binary.patch 1970-01-01 00:00:00.000000000 +0000 +++ weplab-0.1.5/debian/patches/30_fix-spellings-final-binary.patch 2016-11-22 17:02:32.000000000 +0000 @@ -0,0 +1,97 @@ +Description: fix some spelling errors in final binary. +Author: Joao Eriberto Mota Filho +Last-Update: 2016-11-22 +Index: weplab-0.1.5/dictionary.c +=================================================================== +--- weplab-0.1.5.orig/dictionary.c ++++ weplab-0.1.5/dictionary.c +@@ -323,14 +323,14 @@ void dictionary (void){ + c=getchar(); + } + else { +- /* We can't wait for keyboard input as we are reading the dictionnary file from stdin ! ++ /* We can't wait for keyboard input as we are reading the dictionary file from stdin ! + * So we just sleep 10 seconds and print stats */ + sleep(5); + c='\n'; + } + if (c=='\n') kill(mpid,SIGUSR1); + } +- printf("This was the end of the dictionnary attack.\n"); ++ printf("This was the end of the dictionary attack.\n"); + } + + trues=Verify10PacketsWithKey(packets, keys /* XXX */ ); +Index: weplab-0.1.5/main.c +=================================================================== +--- weplab-0.1.5.orig/main.c ++++ weplab-0.1.5/main.c +@@ -80,12 +80,12 @@ void UsageMsg(char *programName){ + printf(" -r, --heuristics file uses weak keys and intelligent bruteforce\n"); + printf(" -a, --analysis analyze file and get lite statistics\n"); + printf(" -m, --multiprocess Assume of processes. Number must be between 1-64. Default 1.\n"); +- printf(" --caplen maximun length of captured packets with --capture (default 80) \n"); ++ printf(" --caplen maximum length of captured packets with --capture (default 80) \n"); + printf(" --fcs assume all captured frames has the FCS field\n"); + printf(" --keyid just analyze specific id Wep packets. Only for 64 bits keys. (default 0)\n"); + printf(" --prismheader assume all captured frames has the Prism header\n"); + printf(" --allow_dups do not control packets with duplicated IVs\n"); +- printf(" --perc uses this minimun percentage of succeed when using FMS cracking\n"); ++ printf(" --perc uses this minimum percentage of succeed when using FMS cracking\n"); + printf(" --wordfile instead of reading words from stdin it uses this text file as wordfile for the dictionary attack\n"); + printf(" --ascii just use bytes 0x00-0x7F for bruteforce wep key with --bruteforce\n"); + printf(" --alpha just use bytes 0x41-0x7A for bruteforce wep key with --bruteforce\n"); +@@ -287,11 +287,11 @@ int main(int argc, char **argv){ + global_v.alpha=1; + }else if (!strncmp(long_options[option_index].name,"caplen",50)){ + totalArgvParameters+=2; +- if (!optarg || optarg[0]=='-' || totalArgvParameters == argc) QuitParameterError("maximun packet lenght must be defined"); ++ if (!optarg || optarg[0]=='-' || totalArgvParameters == argc) QuitParameterError("maximum packet length must be defined"); + global_v.caplen=atoi(optarg); + }else if (!strncmp(long_options[option_index].name,"perc",50)){ + totalArgvParameters+=2; +- if (!optarg || optarg[0]=='-' || totalArgvParameters == argc) QuitParameterError("minimun percentaje of succeed mut be defined as a positive number from 1 to 100"); ++ if (!optarg || optarg[0]=='-' || totalArgvParameters == argc) QuitParameterError("minimum percentage of succeed must be defined as a positive number from 1 to 100"); + global_v.percSucceed=atoi(optarg); + }else if (!strncmp(long_options[option_index].name,"attacks",50)){ + totalArgvParameters+=2; +Index: weplab-0.1.5/wep.c +=================================================================== +--- weplab-0.1.5.orig/wep.c ++++ weplab-0.1.5/wep.c +@@ -274,7 +274,7 @@ int GetLessSizedPackets(pcap_t *pfile, t + }else if(!(wi_h->wi_frame_ctl_1&0x08)){ + if (global_v.prismHeaderPresent) { + if (h.len<144+sizeof(t_wi_frame)) { +- if (global_v.debug>2) debug("Packet %u has negative size with prismheader!! Perhaps you dont need --prismheader"); ++ if (global_v.debug>2) debug("Packet %u has negative size with prismheader!! Perhaps you don't need --prismheader"); + } + } + if (global_v.debug>2) debug("Packet %u is not a DATA type packet",totalPackets); +@@ -300,7 +300,7 @@ int GetLessSizedPackets(pcap_t *pfile, t + + if (global_v.prismHeaderPresent) { + if (h.len<144+sizeof(t_wi_frame)) { +- if (global_v.debug>2) debug("Packet %u has negative size with prismheader!! Perhaps you dont need --prismheader"); ++ if (global_v.debug>2) debug("Packet %u has negative size with prismheader!! Perhaps you don't need --prismheader"); + continue; + } + p_len=h.len-144; +@@ -312,7 +312,7 @@ int GetLessSizedPackets(pcap_t *pfile, t + + if (global_v.key_len==5 && iv[3]!=global_v.keyid) continue; // Si no es la key correcta para 64 bits la ignoro + +- // If total lenght < 802.11 header plus CRC then DATA=0 and packet should be ignored. ++ // If total length < 802.11 header plus CRC then DATA=0 and packet should be ignored. + if (p_len <= sizeof(t_wi_frame)+4) continue; + + if (global_v.debug>2){ +@@ -366,7 +366,7 @@ void DebugView10Packets(t_storedPacket * + int i; + debug("%u packets selected.",totalPackets); + for (i=0; i %u total lenght, %u data lenght (just encrypted data)",i,packets[i]->len,packets[i]->len-sizeof(t_wi_frame)-LEN_IV-LEN_ID); ++ debug("Packet %u --> %u total length, %u data length (just encrypted data)",i,packets[i]->len,packets[i]->len-sizeof(t_wi_frame)-LEN_IV-LEN_ID); + if (global_v.debug>1) DebugViewPacketHeaders(packets[i]->packet); + // debug ("Len EXcluding headers (%d 802.11, %d IV+ID): %d",sizeof(t_wi_frame),LEN_IV+LEN_ID,packets[i]->len-sizeof(t_wi_frame)-LEN_IV-LEN_ID); + } diff -Nru weplab-0.1.5/debian/patches/40_fix-spellings-manpage.patch weplab-0.1.5/debian/patches/40_fix-spellings-manpage.patch --- weplab-0.1.5/debian/patches/40_fix-spellings-manpage.patch 1970-01-01 00:00:00.000000000 +0000 +++ weplab-0.1.5/debian/patches/40_fix-spellings-manpage.patch 2016-11-22 17:02:32.000000000 +0000 @@ -0,0 +1,668 @@ +Description: fix some spelling errors in manpage. +Author: Joao Eriberto Mota Filho +Last-Update: 2016-11-22 +Index: weplab-0.1.5/weplab.1 +=================================================================== +--- weplab-0.1.5.orig/weplab.1 ++++ weplab-0.1.5/weplab.1 +@@ -1,131 +1,131 @@ +-.TH weplab 1 ++.TH weplab 1 + .SH NAME + weplab \- Wireless WEP encryption security analyzer + .SH SYNOPSIS + \fBweplab\fR {\-a | \-r | \-b | \-y | \-c} [options] {\fBpcap file\fR} + .SH DESCRIPTION +-weplab is a tool to review the security of WEP +-encryption in wireless networks from an educational point of view. ++weplab is a tool to review the security of WEP ++encryption in wireless networks from an educational point of view. + Several attacks are available (including advanced statistical attacks) +-so it can be measured the efectiveness and minimun requirements of ++so it can be measured the effectiveness and minimum requirements of + each one. + .PP +-On the other hand, weplab can also be saw as ++On the other hand, weplab can also be saw as + an advanced Wireless WEP encryption cracker that aims to support a big variety +-of attacks. At the moment the attacks supported are dictionary based, ++of attacks. At the moment the attacks supported are dictionary based, + bruteforce and several kind of statistical based. + .SH OPTIONS +-.TP +-\-a, \-\-analyze +-Analyzes specific file and gathers some statistics ++.TP ++\-a, \-\-analyze ++Analyzes specific file and gathers some statistics + about the packets that are stored per detected wlan network. +-.TP +-\-c, \-\-capture ++.TP ++\-c, \-\-capture + Uses a wlan interface to capture wep encrypted data packets. + Those captured packets will be logged into a file in pcap format and can be +-used later to crack the key. +-.TP +-\-b, \-\-bruteforce ++used later to crack the key. ++.TP ++\-b, \-\-bruteforce + Launches a bruteforce attack to break the key. That means +-that weplab will test all possible keys in order to +-find the right one. ++that weplab will test all possible keys in order to ++find the right one. + + Please, that this can take lot of time depending on the key size and your +-processor speed. Refer to Bruteforce method above in this document for futher ++processor speed. Refer to Bruteforce method above in this document for further + information. + +-If no BSSID was specified, those packets who belong to the same network ++If no BSSID was specified, those packets who belong to the same network + as the first one, will be used for the crack. +-.TP +-\-r, \-\-heuristics +-Launches an statistical attack to break the key. This is the ++.TP ++\-r, \-\-heuristics ++Launches an statistical attack to break the key. This is the + fastest method to crack the key if you own enough packets. As an example a + 64\-bit key can be broken from 100.000 packets, and a 128\-bit key from 300.000 + packets, within 1\-2 hours. With enough packets (lets say 900.000), the cracking +-time is matter of seconds. ++time is matter of seconds. + + Several statistical attacks will be used depending on the selected +-stability level (3 by default). The processor time and number of packets ++stability level (3 by default). The processor time and number of packets + required, highly depends on the parameters used to launch the attack. + + This method is very advanced. You are fully encouraged to understand it + reading its section on this document. Although it use to work fine with default +-options and having, enough packets, its better to understand how it works so +-you can tweak the procedure using the apropiate parameters. ++options and having, enough packets, its better to understand how it works so ++you can tweak the procedure using the appropriate parameters. + +-If no BSSID was specified, those packets who belong to the same network ++If no BSSID was specified, those packets who belong to the same network + as the first one, will be used for the crack. +-.TP +-\-y, \-\-dictionary ++.TP ++\-y, \-\-dictionary + Launches a dictionary based attack to break the key. + + Many WEP keys are derived from pass\-phrases, entered by the network +-administrator. When, this happens and you do not have enough packets to ++administrator. When, this happens and you do not have enough packets to + launch a statistical attack, it is better to use a dictionary based cracking +-than a bruteforce aproach. ++than a bruteforce approach. + +-On dictionary attack, John the Ripper is used to generate the words that ++On dictionary attack, John the Ripper is used to generate the words that + weplab will use to derive the WEP key. So, John the Ripper must be present and + executed so its output is piped into weplabs input. In the EXAMPLES section + you will find several examples about that. + +-If no BSSID was specified, those packets who belong to the same network ++If no BSSID was specified, those packets who belong to the same network + as the first one, will be used for the crack. +-.TP ++.TP + \-k, \-\-key \fI\fR + Specify the key length. It can be either 64 or 128\-bit + +-This option is only usefull within a cracking method, so \-y, \-r or \-b ++This option is only useful within a cracking method, so \-y, \-r or \-b + must be used in conjuntion with it. + + Default: 64 bits. +-.TP ++.TP + \-\-keyid \fI\fR + Specify the key id for 64\-bit keys. + + For 64\-bit keys the WEP standard specifies four possible keys, each one +-with a different keyid (0\-3). Usually only keyid 0 is used, but if you hit a ++with a different keyid (0\-3). Usually only keyid 0 is used, but if you hit a + network with more keyids you will need to use this option to specify one of + them, and launch a separate cracking attack for each one. + + Default: 0 +-.TP ++.TP + \-\-fcs +-Specify the presence of a 1 byte FCS tail on all logged ++Specify the presence of a 1 byte FCS tail on all logged + packets + + Depending on your driver and how did you set your card into monitor mode +-, it is possible than logged packets have an aditional tail of 1 byte length. ++, it is possible than logged packets have an additional tail of 1 byte length. + + Best way to find out if your card/drivers needs this, is trying to break + your own network. This way, as you already know the key, if it does not get + cracked without FCS, try with it. + +-This option is only usefull within a cracking method, so \-y, \-r or \-b ++This option is only useful within a cracking method, so \-y, \-r or \-b + must be used in conjuntion with it. + + Default: fcs not present. +-.TP ++.TP + \-\-prismheader + Specify the presence of an special header called PrismHeader + on all logged packets + + Depending on your driver and how did you set your card into monitor mode +-, it is possible than logged packets have an aditional header of 144 bytes length. ++, it is possible than logged packets have an additional header of 144 bytes length. + + If you want to know if you need it or not, just analyze the file with +-weplab. If prismheader is not necessary it will tell you. If it is neccesary, you ++weplab. If prismheader is not necessary it will tell you. If it is necessary, you + will see lot of bogus BSSIDs, and no adversice about not using prismehader + + Anyway, cracking your own WEP key is the best method to know if you need it + or not. + +-This option is only usefull within a cracking method, so \-y, \-r or \-b ++This option is only useful within a cracking method, so \-y, \-r or \-b + must be used in conjuntion with it. From weplab 0.1.2 you will also need to specify + it with \-a in order weplab to show you the right BSSIDs found. + + Default: prismheader not present. +-.TP ++.TP + \-\-bssid \fI\fR + Only use those packets that belongs to the selected BSSID. + +@@ -136,38 +136,38 @@ the first one, will be used + + Use \-a with your file if you want to see all detected BSSIDs + +-This option is only usefull within a cracking method, so \-y, \-r or \-b ++This option is only useful within a cracking method, so \-y, \-r or \-b + must be used in conjuntion with it. + + Default: none +-.TP ++.TP + \-\-caplen \fI\fR + Specify the amount of bytes that will be logged for each packets. + + In order to launch an attack only a few number of packets (10) must be fully + logged. For the statistical attacks, only the first bytes of other packets are +-needed. ++needed. + + In order to save diskspace when logging packets for the statistical attack, +-ony the begining of the packet should be logged ++only the beginning of the packet should be logged + + If you specify 0 here, the whole packet will be logged. + + Please, notice that you will need to capture at least 10 packets behind this +-amount (fully logged packets), as they will be needed for testing candidate keys ++amount (fully logged packets), as they will be needed for testing candidate keys + within the cracking process. + + Default: 1500 +-.TP ++.TP + \-i \fI\fR + Specifies the wireless interface that will be used to capture + packets. + + weplab does not set the interface into monitor mode, so you must do it yourself + before capturing packets. Read the above to learn how to do it. +-.TP ++.TP + \-m, \-\-multiprocess \fI\fR +-Specifies the number of threads that will be launched to ++Specifies the number of threads that will be launched to + take advantage of multiprocessors systems. If your microprocessor supports + hyperthreading please use the double of number of microprocessors. + +@@ -177,7 +177,7 @@ if you own a dual processor P\-II machin + At the moment this option does only work on bruteforce attack. + + Default: 1 +-.TP ++.TP + \-\-ascii + When launching a bruteforce attack, it is faster to search + only ascii bytes if you are sure that the WEP key was generating from a pass +@@ -185,98 +185,98 @@ phrase using ascii direct\-mapping. + + This way, each key byte will only be tested in the range of 00\-3F. As + the key\-space is smaller the attack is faster. +-.TP ++.TP + \-\-perc \fI\fR +-Specify the desired minimun probability for the statistical attack. ++Specify the desired minimum probability for the statistical attack. + It means that at least enough candidate key bytes will be tested to fit this probability. + +-In order to fully understand this option you are encouraged to read carefully the +-"Statistical Attacks" caption, above in this document. ++In order to fully understand this option you are encouraged to read carefully the ++"Statistical Attacks" caption, above in this document. + +-Please note that the higher the minimun probability the slowest the attack. ++Please note that the higher the minimum probability the slowest the attack. + For most cases 50% is fine. You can increase to 60 or 70% if you get the KEY NOT FOUND with 50, but never + increase it to 100% because you will be waiting for ever. +-.TP ++.TP + \-\-stability \fI\fR +-Specify the predefined set of statistical attacks based on their stability level. Not all ++Specify the predefined set of statistical attacks based on their stability level. Not all + the statistical attacks are stable (works fine) your every key. Some of them are more unstable than others. + This options allows you to launch only those attacks that meets the specified stability level. + +-Level can be from 1 to 5. The highest the more stable. I do not recomment you to go for level 1 because ++Level can be from 1 to 5. The highest the more stable. I do not recommend you to go for level 1 because + it is too unstable to give you any results. By default level 3 is used. It is a good idea to change into level 2 + if you have little unique IV and cracking with level 3 failed. + + In the Statistical Attack caption, you will find a detailed list of the 17 attacks implemented with the + stability level of each one. +-.TP ++.TP + \-\-attacks \fI#attack1,#attack2,#attack2\fR + This is the other way to select the statistical attacks that will be launched, without + using \-\-stability parameter. Only those attacks, whose number is selected here, will be used in the + statistical procedure. + +-The number of the attacks go from 1 to 17. Please, refer to the Statistical Attacks section for ++The number of the attacks go from 1 to 17. Please, refer to the Statistical Attacks section for + further information. +-.TP ++.TP + \-\-debugkey \fI\fR + if you want to test how a set of statistical attacks works with a known WEP key, then +-this parameter will give you the oportunity to get the final result without going trhow all the possible ++this parameter will give you the opportunity to get the final result without going trhow all the possible + branches. + + Using this option you tell weplab about the WEP key used to encrypt the packets. Only the real branch + will be followed and you will get the candidate list for each key byte. +-.TP +-\-V ++.TP ++\-V + Outputs version information and exists. +-.TP +-\-h ++.TP ++\-h + Displays command line parameters help. + .SH INSTALLATION +-weplab does not need any special installation. It runs in userlevel and only requires the libpcap ++weplab does not need any special installation. It runs in userlevel and only requires the libpcap + libraries (>=0.8) to be present. + For most functions weplab can be executed by any user, however for packet capture functionality it must be executed + by root. + .PP +-if you are installing it from source code distribution, the configure script should be able to detect +-your proccessor type to optimize the code specifically for your platform. ++if you are installing it from source code distribution, the configure script should be able to detect ++your processor type to optimize the code specifically for your platform. + .PP +-At least 128 MB of free RAM memmory are required to run FMS statistical attack in weplab, ++At least 128 MB of free RAM memory are required to run FMS statistical attack in weplab, + 64 MB of free ram for capturing packets, and nothing special for the other features. + .PP + Weplab is reported to work fine under GNU/Linux for intel, GNU/Linux for PPC and MacOSX. + .PP + Windows version cannot capture packets due to the lack of a opensource method to do it, but its +-other features works fine. Please read Windows Platform section under Capture Packets caption for +-futher information about how to deal with this issue under Windows. ++other features works fine. Please read Windows Platform section under Capture Packets caption for ++further information about how to deal with this issue under Windows. + .SH "CAPTURING PACKETS" + First you will need to capture 802.11b encrypted packets to crack the wep key. + The way weplab cracks the key is using passive attacks to an already captured packet set. + .PP +-To capture encrypted packets in a wireless network, your wireless card must be put +-in monitor mode. The way monitor mode is set is highly dependant on which card do you own, ++To capture encrypted packets in a wireless network, your wireless card must be put ++in monitor mode. The way monitor mode is set is highly dependent on which card do you own, + and which drivers are you using. + .PP +-Explaining how to set monitor mode in your card is beyond the scope of this document, +-and sometimes involves patching the kernel or "hacking" the drivers. As an example, the +-following steps should be done in order to set monitor mode on a prism2 based card using ++Explaining how to set monitor mode in your card is beyond the scope of this document, ++and sometimes involves patching the kernel or "hacking" the drivers. As an example, the ++following steps should be done in order to set monitor mode on a prism2 based card using + wlan\-ng drivers. +-.TP ++.TP + Initialization of the card. + prism2 and wlan\-ng + + wlanctl\-ng wlan0 lnxreq_ifstate ifstate=enable + +-wlanctl\-ng wlan0 lnxreq_autojoin ssid=any authtype=opensystem ++wlanctl\-ng wlan0 lnxreq_autojoin ssid=any authtype=opensystem + + orinoco : nothing special +-.TP ++.TP + Enable the interface (wlan0 in the example, just change to eth0 if using orinoco) + ifconfig wlan0 up +-.TP ++.TP + Setting monitor mode on desired channel (6 in the example). + prism2 and wlan\-ng + + wlanctl\-ng wlan0 lnxreq_wlansniff channel=06 keepwepflags=false prismheader=false enable=true +-(I dont know why, but sometimes this step must be taken twice :) ) ++(I don't know why, but sometimes this step must be taken twice :) ) + + orinoco and iwpriv + +@@ -284,154 +284,154 @@ iwpriv eth0 monitor 2 6 + .PP + There are a few things that must be done regardless of the card and drivers used. + .PP +-1. The wireless card placed in monitor mode should accept encrypted packets and mark them ++1. The wireless card placed in monitor mode should accept encrypted packets and mark them + as encrypted. In the example above, that's the purpose of the option keepwepflags=false in third step. + .PP + 2. The interface must be enabled (up) + .PP +-3. If your card is appending prism header or fcs "tail" to the packets, weplab needs to be +-told about it (with \-\-fcs or \-\-prismheader). Determining if this is necessary for your hardware ++3. If your card is appending prism header or fcs "tail" to the packets, weplab needs to be ++told about it (with \-\-fcs or \-\-prismheader). Determining if this is necessary for your hardware + will be explained later. + .PP +-Now, to capture encrypted packets you can either use weplab, tcpdump, or a similar sniffer ++Now, to capture encrypted packets you can either use weplab, tcpdump, or a similar sniffer + that logs packets in pcap format. + .PP + To do it with weplab, just use \-c. Interface must be specified with \-i + + weplab \-\-debug 1 \-c \-i wlan0 ./packets.log + +-There is no need to log the entire packet, just the 802.11 header and the IV, but to verify +-possible canditate keys the whole packet encrypted payload must be present. That's why you must +-specify two files in weplab when using FMS attack. One file must have just 10 packets with the ++There is no need to log the entire packet, just the 802.11 header and the IV, but to verify ++possible candidate keys the whole packet encrypted payload must be present. That's why you must ++specify two files in weplab when using FMS attack. One file must have just 10 packets with the + whole payload, and the other file contains weak packets that don't need to have payload logged. + .PP +-So, in order to save disk space it is a good idea to log a few packets for key verification on +-one file, and then just log the first bytes of all other possible packets, to be used as possible ++So, in order to save disk space it is a good idea to log a few packets for key verification on ++one file, and then just log the first bytes of all other possible packets, to be used as possible + weak packet for FMS attack. + .PP +-You can specify maximun captured bytes per packet with \-\-caplen bytes ++You can specify maximum captured bytes per packet with \-\-caplen bytes + + weplab \-c \-i wlan0 \-\-debug 1 ./verification_packets.logweplab \-c \-i wlan0 \-\-debug 1 \-\-caplen 100 ./weak_packets.log + +-Alternately, if your disk space is not so critical and you don't mind wasting a few ++Alternately, if your disk space is not so critical and you don't mind wasting a few + extra seconds on loading the file later, these two steps can be joined into one. + + weplab \-c \-i wlan0 \-\-debug 1 \-\-caplen 150 ./packets.log + + Then this file can be used both for verification and weak packets. + .SH "ANALYZING PCAP FILE" +-Before trying to crack the key using the already captured packets, it is a good +-idea to verify the file just to ensure that the packets were logged fine, and there are +-enough to perform the desired attack. ++Before trying to crack the key using the already captured packets, it is a good ++idea to verify the file just to ensure that the packets were logged fine, and there are ++enough to perform the desired attack. + + weplab \-\-debug 1 \-a ./packets.log + +-You can try with \-\-prismheader or \-\-fcs, or both. ++You can try with \-\-prismheader or \-\-fcs, or both. + + weplab \-\-debug 1 \-a \-\-fcs ./packets.logweplab \-\-debug 1 \-a \-\-prismheader \-\-fcs ./packets.log + +-As explained above, prismheader is an special header that some cards and drivers +-add to all captured packets, and fcs is an special tail added to the captured packets by ++As explained above, prismheader is an special header that some cards and drivers ++add to all captured packets, and fcs is an special tail added to the captured packets by + some drivers. +-You can determine if your card/drivers needs \-\-fcs or \-\-prismheaders by using the FMS attack +-together with \-\-debugkey and a set of encrypted packets captured by your card where the wep ++You can determine if your card/drivers needs \-\-fcs or \-\-prismheaders by using the FMS attack ++together with \-\-debugkey and a set of encrypted packets captured by your card where the wep + key is known. This is explained later in the FMS attack section. + .SH "WEP KEY CRACKING." + At the moment weplab supports 2 main cracking methods: bruteforce and FMS statistical attack. +-Before selecting the cracking method, the keysize should be specified. By default the keysize is 64. ++Before selecting the cracking method, the keysize should be specified. By default the keysize is 64. + To crack a 128\-bit key, you must specify \-\-key 128 + .SH "BRUTEFORCE CRACKING." +-Bruteforce cracking means testing all possible keys to find the right one. +-That means that each key byte can take values from 0 to 255. So a quick calculus will reveal +-that for a 64 bits key the total combinations are 2^40, so at 100.000 c/s cracking the key +-will take you 4100061318 seconds maximun. 127 days working fulltime. +-.PP +-With a 128\-bit key the total combinations possible are 2^104, so at 100.000 c/s +-the total maximun amount of time will be 6520836420927105974 YEARS!! +-I guess you will never try to launch a bruteforce attack to a 128\-bit key. ++Bruteforce cracking means testing all possible keys to find the right one. ++That means that each key byte can take values from 0 to 255. So a quick calculus will reveal ++that for a 64 bits key the total combinations are 2^40, so at 100.000 c/s cracking the key ++will take you 4100061318 seconds maximum. 127 days working full time. ++.PP ++With a 128\-bit key the total combinations possible are 2^104, so at 100.000 c/s ++the total maximum amount of time will be 6520836420927105974 YEARS!! ++I guess you will never try to launch a bruteforce attack to a 128\-bit key. + Anyway, weplab gives you the possibility to do it ;) + .PP +-You will need at least 10 full wep encrypted data captured packets in order ++You will need at least 10 full wep encrypted data captured packets in order + to launch a bruteforce attack avoiding false positives. +-.SH "DICTIONNARY CRACKING" +-Guess what ? Users often use simple words as their WEP key. The dictionnary cracking +-mode gives you the ability to check if the WEP key isn't a so\-simple\-to\-guess word. Using +-this mode in addition to John\-the\-Ripper could produce some usefull results. ++.SH "DICTIONARY CRACKING" ++Guess what ? Users often use simple words as their WEP key. The dictionary cracking ++mode gives you the ability to check if the WEP key isn't a so\-simple\-to\-guess word. Using ++this mode in addition to John\-the\-Ripper could produce some useful results. + .PP +-Weplab reads the dictionnary words from STDIN, so if you want statistics, you want ++Weplab reads the dictionary words from STDIN, so if you want statistics, you want + be able to press SPACE. However, you'll have statistics printed on STDOUT every 10 seconds. + .PP + Dictionary cracking can use two different modes : + .PP +-By default the classical algorithm (MD5 for 128 bits keys or one of 4 +-keys for 40 bits keys) it is used. This mode is widely used on Access Points to generate ++By default the classical algorithm (MD5 for 128 bits keys or one of 4 ++keys for 40 bits keys) it is used. This mode is widely used on Access Points to generate + keys from a passphrase. + .PP +-Alternatively you can select Word to key with the "\-\-attack 2" option if you want +-weplab to use plaintext keys with NULL bytes appended (if needed) at the end of each ++Alternatively you can select Word to key with the "\-\-attack 2" option if you want ++weplab to use plaintext keys with NULL bytes appended (if needed) at the end of each + word to fit the WEP key size. + This second mode is used on my system when I configure the WEP key using "iwconfig eth0 s:silly". + .SH "FMS STATISTICAL ATTACK" +-Wireless networks WEP encryption is based on RC4 algorithm. RC4 has some weaknesses +-as Fluhrer, Mantin and Shamir described in 2001 with the paper "Weaknesses in the Key +-Scheduling Algorithm of RC4". The specific implementation of the RC4 algorithm in WEP makes +-possible its practical use. The initials of the authors gave it the name of FMS statistical ++Wireless networks WEP encryption is based on RC4 algorithm. RC4 has some weaknesses ++as Fluhrer, Mantin and Shamir described in 2001 with the paper "Weaknesses in the Key ++Scheduling Algorithm of RC4". The specific implementation of the RC4 algorithm in WEP makes ++possible its practical use. The initials of the authors gave it the name of FMS statistical + cryptoanalysis. + .PP +-In order to make this attack possible for breaking the encryption of wireless +-networks, lots of specific data wep encrypted packets, called weak packets, must be +-gathered. Soon after the paper was published, two tools appeared that implemented the FMS +-attack, but the set of weak packets that these tools use is just asmall subset of the total ++In order to make this attack possible for breaking the encryption of wireless ++networks, lots of specific data wep encrypted packets, called weak packets, must be ++gathered. Soon after the paper was published, two tools appeared that implemented the FMS ++attack, but the set of weak packets that these tools use is just a small subset of the total + possible weak packets. As a result, the attack was not as practical to launch as it should be. + .PP +-In February 2002, h1kari released the paper "Practical Exploitation of RC4 Weaknesses +-in WEP Environments". This describes the problem with the set of weak packets used by existing +-tools and suggest several optimization in the attack like attacking other bytes besides the ++In February 2002, h1kari released the paper "Practical Exploitation of RC4 Weaknesses ++in WEP Environments". This describes the problem with the set of weak packets used by existing ++tools and suggest several optimization in the attack like attacking other bytes besides the + first one. H1kari created a tool called dwepcrack that implements a part of these optimizations, +-and runs under *BSD. Weplab uses FMS attack supporting the whole set of weak packets for +-attacking both the first and the second byte of the encrypted payload. Also some bruteforce +-and smart probabilistic based decisions are implemented within the FMS attack to make +-it more powerful, especially when you dont have enough packets to launch a ++and runs under *BSD. Weplab uses FMS attack supporting the whole set of weak packets for ++attacking both the first and the second byte of the encrypted payload. Also some bruteforce ++and smart probabilistic based decisions are implemented within the FMS attack to make ++it more powerful, especially when you don't have enough packets to launch a + straight\-forward attack. + .PP +-But apart from that, the main purpose of weplab is to be an educational tool to help +-users understand the existing weaknesses in WEP and how can the be used to break the encryption ++But apart from that, the main purpose of weplab is to be an educational tool to help ++users understand the existing weaknesses in WEP and how can the be used to break the encryption + key. Several command line parameters are implemented with this purpose. + .PP +-Also, if you plan to test weplab cracking capacity with your own wireless lan, +-you can use \-\-debugkey. By using this option you tell weplab what your WEP key is +-(or at least a part of it), so weplab will skip all other branches when searching candidate ++Also, if you plan to test weplab cracking capacity with your own wireless lan, ++you can use \-\-debugkey. By using this option you tell weplab what your WEP key is ++(or at least a part of it), so weplab will skip all other branches when searching candidate + key bytes in FMS attack. + .SH "NEW STATISTICAL ATTACKS" +-New statistical attacks published on Netstumbler forum by Korek. These new attacks ++New statistical attacks published on Netstumbler forum by Korek. These new attacks + make possible to crack the key with even less than 500k. + .PP + Many thanks to Korek for this information. All the credit goes to you. + .SH EXAMPLES + Example 1. Cracking using FMS attack + +-You want to test the tool so you collect 1.5M packets from your own wireless LAN. ++You want to test the tool so you collect 1.5M packets from your own wireless LAN. + You just want to know if weplab would be able to crack it. +-You can use first \-\-debugkey. If you are using a 128\-bit key the right sintax would be: ++You can use first \-\-debugkey. If you are using a 128\-bit key the right syntax would be: + .PP +-weplab \-r./packets.log \-\-debugkey 01:02:03:04:05:06:07:08:09:10:11:12:13 \-\-debug 1 +-\-\-key 128 ./packets.log ++weplab \-r./packets.log \-\-debugkey 01:02:03:04:05:06:07:08:09:10:11:12:13 \-\-debug 1 ++\-\-key 128 ./packets.log + .PP +-You should see the statistics and guesses for each byte of the key so you can see the viability +-of the attack. At the end you should see "key succesfully cracked". If you do not see such message, +-perhaps your captured packets have the FCS tail so it will be neccesary to issue \-\-fcs ++You should see the statistics and guesses for each byte of the key so you can see the viability ++of the attack. At the end you should see "key successfully cracked". If you do not see such message, ++perhaps your captured packets have the FCS tail so it will be necessary to issue \-\-fcs + .PP +-weplab \-r./packets.log \-\-debugkey 01:02:03:04:05:06:07:08:09:10:11:12:13 +-\-\-fcs \-\-debug 1 \-\-key 128 ./packets.log ++weplab \-r./packets.log \-\-debugkey 01:02:03:04:05:06:07:08:09:10:11:12:13 ++\-\-fcs \-\-debug 1 \-\-key 128 ./packets.log + .PP +-Now can try with just a part of the key in debugkey. If the FMS is possible with these packets, ++Now can try with just a part of the key in debugkey. If the FMS is possible with these packets, + weplab should be able to crack the key using just these bytes. + .PP +-weplab \-r./packets.log \-\-debugkey 01:02:03:04:05:06 \-\-fcs \-\-debug 1 \-\-key 128 +-\&./packets.log ++weplab \-r./packets.log \-\-debugkey 01:02:03:04:05:06 \-\-fcs \-\-debug 1 \-\-key 128 ++\&./packets.log + .PP +-If it works you can try reducing the debugkey more. At the end you can try with +-no debugkey at all, as if it were a real attack. ++If it works you can try reducing the debugkey more. At the end you can try with ++no debugkey at all, as if it were a real attack. + .PP + You can push ENTER key in any moment to get statistics of the work done. + .PP +@@ -439,34 +439,34 @@ Example 2. Cracking using bruteforce + .PP + To crack a 64\-bit key using normal bruteforce just issue the following command. + .PP +-weplab \-\-debug 1 \-\-key 64 ./packets.log ++weplab \-\-debug 1 \-\-key 64 ./packets.log + .PP + If you suspect that the key may be in plain ascii, do this: + .PP +-weplab \-\-debug 1 \-\-key 64 \-\-ascii ./packets.log ++weplab \-\-debug 1 \-\-key 64 \-\-ascii ./packets.log + .PP + You can push ENTER key at any moment to get statistics of the work done. + .PP + Example 3. Capturing packets. + .PP +-In order to capture packets you have to put your wireless card in monitor mode in the right channel. +-Be carefull to configure monitor mode to ignore WEP bit. ++In order to capture packets you have to put your wireless card in monitor mode in the right channel. ++Be careful to configure monitor mode to ignore WEP bit. + Once you have your card in monitor mode, you can capture packets using tcpdump or weplab \-c \-i interface + .PP +-weplab \-c \-i wlan0 \-\-debug 1 \-\-caplen 150 ./packets.log ++weplab \-c \-i wlan0 \-\-debug 1 \-\-caplen 150 ./packets.log + .PP + You can push ENTER key at any moment to get statistics of the work done. + .PP + Example 4. Analyze an existing pcap file. + .PP +-Weplab can also analyze a pcap file to the some statistics. Use \-a for this purpose. ++Weplab can also analyze a pcap file to the some statistics. Use \-a for this purpose. + \-\-prismheader \-\-fcs can also be used. + .PP + weplab \-a \-\-debug 1 ./pcap.log + .PP +-Example 5. Cracking a 64 WEP key using a dictionnary file with John the Ripper ++Example 5. Cracking a 64 WEP key using a dictionary file with John the Ripper + .PP +-john \-w:/path/to/my/big/dictionnaryfile \-rules \-stdout | weplab \-y \-d 1 \-\-key 64 capt.dump ++john \-w:/path/to/my/big/dictionaryfile \-rules \-stdout | weplab \-y \-d 1 \-\-key 64 capt.dump + .SH VERSION + This man page is correct for version 0.1.3 of weplab + .SH AUTHOR +Index: weplab-0.1.5/heuristics.c +=================================================================== +--- weplab-0.1.5.orig/heuristics.c ++++ weplab-0.1.5/heuristics.c +@@ -306,7 +306,7 @@ int GetWeakPackets(pcap_t *pfile, t_Stor + + if (global_v.prismHeaderPresent) { + if (h.len<144+sizeof(t_wi_frame)) { +- if (global_v.debug>2) debug("Packet %u has negative size with prismheader!! Perhaps you dont need --prismheader"); ++ if (global_v.debug>2) debug("Packet %u has negative size with prismheader!! Perhaps you don't need --prismheader"); + continue; + } + pkt+=144; +Index: weplab-0.1.5/analpfile.c +=================================================================== +--- weplab-0.1.5.orig/analpfile.c ++++ weplab-0.1.5/analpfile.c +@@ -133,7 +133,7 @@ void AnalyzePcapFile(void){ + + if (global_v.prismHeaderPresent) { + if (h.len<144+sizeof(t_wi_frame)) { +- if (global_v.debug>2) debug("Packet %u has negative size with prismheader!! Perhaps you dont need --prismheader"); ++ if (global_v.debug>2) debug("Packet %u has negative size with prismheader!! Perhaps you don't need --prismheader"); + bssidStatArray[indexArray].totalPacketsNegativePrismheader++; + continue; + } diff -Nru weplab-0.1.5/debian/patches/series weplab-0.1.5/debian/patches/series --- weplab-0.1.5/debian/patches/series 1970-01-01 00:00:00.000000000 +0000 +++ weplab-0.1.5/debian/patches/series 2016-11-22 17:02:32.000000000 +0000 @@ -0,0 +1,4 @@ +10_fix-headers_and_warnings.patch +20_modernize_automake_call.patch +30_fix-spellings-final-binary.patch +40_fix-spellings-manpage.patch diff -Nru weplab-0.1.5/debian/rules weplab-0.1.5/debian/rules --- weplab-0.1.5/debian/rules 2016-11-23 06:30:23.000000000 +0000 +++ weplab-0.1.5/debian/rules 2016-11-22 17:02:32.000000000 +0000 @@ -1,75 +1,8 @@ #!/usr/bin/make -f - -# Uncomment this to turn on verbose mode. #export DH_VERBOSE=1 -# These are used for cross-compiling and for saving the configure script -# from having to guess our platform (since we know it already) -DEB_HOST_GNU_TYPE ?= $(shell dpkg-architecture -qDEB_HOST_GNU_TYPE) -DEB_BUILD_GNU_TYPE ?= $(shell dpkg-architecture -qDEB_BUILD_GNU_TYPE) - -CFLAGS = -Wall -g -std=gnu89 -ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS))) - CFLAGS += -O0 -else - CFLAGS += -O2 -endif - -config.status: configure - dh_testdir -ifneq "$(wildcard /usr/share/misc/config.sub)" "" - cp -f /usr/share/misc/config.sub config.sub -endif -ifneq "$(wildcard /usr/share/misc/config.guess)" "" - cp -f /usr/share/misc/config.guess config.guess -endif - ./configure --host=$(DEB_HOST_GNU_TYPE) \ - --build=$(DEB_BUILD_GNU_TYPE) \ - --prefix=/usr \ - --mandir=\$${prefix}/share/man \ - CFLAGS="$(CFLAGS)" \ - LDFLAGS="-Wl,-z,defs" - - -build: build-stamp -build-stamp: config.status - dh_testdir - $(MAKE) - touch $@ - -clean: - dh_testdir - dh_testroot - rm -f build-stamp \ - config.sub \ - config.guess - [ ! -f Makefile ] || $(MAKE) distclean - dh_clean - -install: build - dh_testdir - dh_testroot - dh_clean -k - dh_installdirs - $(MAKE) install DESTDIR=$(CURDIR)/debian/weplab - - -binary-indep: build install -binary-arch: build install - dh_testdir - dh_testroot - dh_installchangelogs ChangeLog - dh_installdocs - dh_link - dh_strip - dh_compress - dh_fixperms - dh_makeshlibs - dh_installdeb - dh_shlibdeps - dh_gencontrol - dh_md5sums - dh_builddeb +export DEB_BUILD_MAINT_OPTIONS = hardening=+all +export DEB_CFLAGS_MAINT_APPEND = -std=gnu89 -binary: binary-indep binary-arch -.PHONY: build clean binary-indep binary-arch binary install +%: + dh $@ --with autoreconf diff -Nru weplab-0.1.5/debian/rules.OLD weplab-0.1.5/debian/rules.OLD --- weplab-0.1.5/debian/rules.OLD 1970-01-01 00:00:00.000000000 +0000 +++ weplab-0.1.5/debian/rules.OLD 2016-11-22 17:02:32.000000000 +0000 @@ -0,0 +1,75 @@ +#!/usr/bin/make -f + +# Uncomment this to turn on verbose mode. +#export DH_VERBOSE=1 + +# These are used for cross-compiling and for saving the configure script +# from having to guess our platform (since we know it already) +DEB_HOST_GNU_TYPE ?= $(shell dpkg-architecture -qDEB_HOST_GNU_TYPE) +DEB_BUILD_GNU_TYPE ?= $(shell dpkg-architecture -qDEB_BUILD_GNU_TYPE) + +CFLAGS = -Wall -g -std=gnu89 +ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS))) + CFLAGS += -O0 +else + CFLAGS += -O2 +endif + +config.status: configure + dh_testdir +ifneq "$(wildcard /usr/share/misc/config.sub)" "" + cp -f /usr/share/misc/config.sub config.sub +endif +ifneq "$(wildcard /usr/share/misc/config.guess)" "" + cp -f /usr/share/misc/config.guess config.guess +endif + ./configure --host=$(DEB_HOST_GNU_TYPE) \ + --build=$(DEB_BUILD_GNU_TYPE) \ + --prefix=/usr \ + --mandir=\$${prefix}/share/man \ + CFLAGS="$(CFLAGS)" \ + LDFLAGS="-Wl,-z,defs" + + +build: build-stamp +build-stamp: config.status + dh_testdir + $(MAKE) + touch $@ + +clean: + dh_testdir + dh_testroot + rm -f build-stamp \ + config.sub \ + config.guess + [ ! -f Makefile ] || $(MAKE) distclean + dh_clean + +install: build + dh_testdir + dh_testroot + dh_clean -k + dh_installdirs + $(MAKE) install DESTDIR=$(CURDIR)/debian/weplab + + +binary-indep: build install +binary-arch: build install + dh_testdir + dh_testroot + dh_installchangelogs ChangeLog + dh_installdocs + dh_link + dh_strip + dh_compress + dh_fixperms + dh_makeshlibs + dh_installdeb + dh_shlibdeps + dh_gencontrol + dh_md5sums + dh_builddeb + +binary: binary-indep binary-arch +.PHONY: build clean binary-indep binary-arch binary install diff -Nru weplab-0.1.5/debian/source/format weplab-0.1.5/debian/source/format --- weplab-0.1.5/debian/source/format 1970-01-01 00:00:00.000000000 +0000 +++ weplab-0.1.5/debian/source/format 2016-11-22 17:02:32.000000000 +0000 @@ -0,0 +1 @@ +3.0 (quilt) diff -Nru weplab-0.1.5/debian/source/include-binaries weplab-0.1.5/debian/source/include-binaries --- weplab-0.1.5/debian/source/include-binaries 1970-01-01 00:00:00.000000000 +0000 +++ weplab-0.1.5/debian/source/include-binaries 2016-11-22 17:02:32.000000000 +0000 @@ -0,0 +1,10 @@ +analpfile.o +attack.o +bruteforce.o +capture.o +debug.o +dictionary.o +globals.o +heuristics.o +md5.o +wep.o diff -Nru weplab-0.1.5/debian/watch weplab-0.1.5/debian/watch --- weplab-0.1.5/debian/watch 2016-11-23 06:30:23.000000000 +0000 +++ weplab-0.1.5/debian/watch 2016-11-22 17:02:32.000000000 +0000 @@ -1,2 +1,2 @@ -version=3 -http://sf.net/weplab/weplab-(.+)\.tar\.gz +version=4 +http://sf.net/weplab/weplab-(\d\S+)\.tar\.(?:bz2|gz|xz)