6.

TECHNOLOGIES USED

6.1 PYTHON PROGRAMMING LANGUAGE

Python is a widely used high-level programming language for general-purpose programming,

created by Guido van Rossum and first released in 1991. An interpreted language, Python has a
design philosophy which emphasizes code readability (notably using whitespace indentation to
delimit code blocks rather than curly braces or keywords), and a syntax which allows programmers
to express concepts in fewer lines of code than possible in languages such as C++ or Java. The
language provides constructs intended to enable writing clear programs on both a small and large
scale.

The Python programming language

Python features a dynamic type system and automatic memory management and supports multiple
programming paradigms, including object-oriented, imperative, functional programming, and
procedural styles. It has a large and comprehensive standard library.

Python interpreters are available for many operating systems, allowing Python code to run on a
wide variety of systems. CPython, the reference implementation of Python, is open source software
and has a community-based development model, as do nearly all of its variant implementations.
CPython is managed by the non-profit Python Software Foundation.

The core philosophy of the language is summarized by the document The Zen of Python (PEP 20),
which includes aphorisms such as:

 Beautiful is better than ugly

  Explicit is better than implicit
 Simple is better than complex
 Complex is better than complicated
 Readability counts

Syntax and semantics

Python is intended to be a highly readable language. It is designed to have an uncluttered visual

layout, often using English keywords where other languages use punctuation. Further, Python has
fewer syntactic exceptions and special cases than C or Pascal.

Indentation

Python uses whitespace indentation to delimit blocks – rather than curly braces or keywords. An
increase in indentation comes after certain statements; a decrease in indentation signifies the end
of the current block. This feature is also sometimes termed the off-side rule.
Statements and control flow

 The assignment statement (token '=', the equals sign). This operates differently than in
traditional imperative programming languages, and this fundamental mechanism
(including the nature of Python's version of variables) illuminates many other features of
the language. Assignment in C, e.g., x = 2, translates to "typed variable name x receives a
copy of numeric value 2".
 The if statement, which conditionally executes a block of code, along with else and elif (a
contraction of else-if).
 The for statement, which iterates over an iterable object, capturing each element to a local
variable for use by the attached block.
 The while statement, which executes a block of code as long as its condition is true.
 The try statement, which allows exceptions raised in its attached code block to be caught
and handled by except clauses; it also ensures that clean-up code in a finally block will
always be run regardless of how the block exits.
 The class statement, which executes a block of code and attaches its local namespace to a
class, for use in object-oriented programming.
 The def statement, which defines a function or method.
Expressions
Some Python expressions are similar to languages such as C and Java, while some are not:

 Addition, subtraction, and multiplication are the same, but the behavior of division differs.
Python also added the ** operator for exponentiation.
 As of Python 3.5, it supports matrix multiplication directly with the @ operator, versus C
and Java, which implement these as library functions. Earlier versions of Python also used
methods instead of an infix operator.
 In Python, == compares by value, versus Java, which compares numerics by value and
objects by reference. (Value comparisons in Java on objects can be performed with the
method.) Python's is operator may be used to compare object identities (comparison by
reference). In Python, comparisons may be chained, for example a <= b <= c.
 Python uses the words and, or, not for its boolean operators rather than the symbolic &&,
||,! used in Java and C.

Methods

Methods on objects are functions attached to the object's class; the syntax instance.
Method(argument) is, for normal methods and functions, syntactic sugar for Class. Method
(instance, argument). Python methods have an explicit self-parameter to access instance data, in
contrast to the implicit self (or this) in some other object-oriented programming languages (e.g.,
C++, Java, Objective-C, or Ruby)

Typing

Python uses duck typing and has typed objects but untyped variable names. Type constraints are
not checked at compile time; rather, operations on an object may fail, signifying that the given
object is not of a suitable type. Despite being dynamically typed, Python is strongly typed,
forbidding operations that are not well-defined (for example, adding a number to a string) rather
than silently attempting to make sense of them.

Python allows programmers to define their own types using classes, which are most often used for
object-oriented programming. New instances of classes are constructed by calling the class (for
example, SpamClass() or EggsClass()), and the classes are instances of the metaclass type
(itself an instance of itself), allowing metaprogramming and reflection.
6.2 DEBIAN 8 OPERATING SYSYTEM

The Debian Project is an association of individuals who have made common cause to create a free
operating system. This operating system that we have created is called Debian.
An operating system is the set of basic programs and utilities that make your computer run. At the
core of an operating system is the kernel. The kernel is the most fundamental program on the
computer and does all the basic housekeeping and lets you start other programs.

Debian Operating system

Debian systems currently use the Linux kernel or the FreeBSD kernel. Linux is a piece of software
started by Linus Torvalds and supported by thousands of programmers worldwide. FreeBSD is an
operating system including a kernel and other software.

However, work is in progress to provide Debian for other kernels, primarily for the Hurd. The
Hurd is a collection of servers that run on top of a microkernel (such as Mach) to implement
different features. The Hurd is free software produced by the GNU project.

It’s all free?

You may be wondering: why would people spend hours of their own time to write software,
carefully package it, and then give it all away? The answers are as varied as the people who
contribute. Some people like to help others. Many write programs to learn more about computers.
More and more people are looking for ways to avoid the inflated price of software. A growing
crowd contribute as a thank you for all the great free software they've received from others. Many
in academia create free software to help get the results of their research into wider use. Businesses
help maintain free software so they can have a say in how it develops -- there's no quicker way to
get a new feature than to implement it yourself! Of course, a lot of us just find it great fun.
Debian is so committed to free software that we thought it would be useful if that commitment
was formalized in a written document. Thus, our Social Contract was born.

Although Debian believes in free software, there are cases where people want or need to put non-
free software on their machine. Whenever possible Debian will support this. There are even a
growing number of packages whose sole job is to install non-free software into a Debian system

What hardware is supported?

Debian will run on almost all personal computers, including most older models. Each new release
of Debian generally supports a larger number of computer architectures. For a complete list of
currently supported ones, see the documentation for the stable release.

There are a few companies that make support difficult by not releasing specifications for their
hardware. This means you might not be able to use their hardware with GNU/Linux. Some
companies provide non-free drivers, but that is a problem because the company could later go out
of business or stop support for the hardware you have. We recommend that you only purchase
hardware from manufacturers that provide free drivers for their products.

How do I get Debian?

It's most popular to install Debian from a CD which you can buy for the price of the media at one
of our many CD vendors. If you have good Internet access, you can download and install Debian
over the Internet.

6.3 PyCharm IDE

PyCharm is an Integrated Development Environment (IDE) used in computer programming,

specifically for the Python language. It is developed by the Czech company JetBrains. It provides
code analysis, a graphical debugger, an integrated unit tester, integration with version control
systems (VCSes), and supports web development with Django.
PyCharm is cross-platform, with Windows, macOS and Linux versions. The Community Edition
is released under the Apache License, and there is also Professional Edition released under a
proprietary license - this has extra features.

Pycharm IDE

Features

 Coding Assistance and Analysis, with code completion, syntax and error highlighting,
linter integration, and quick fixes
 Project and Code Navigation: specialized project views, file structure views and quick
jumping between files, classes, methods and usages
  Python Refactoring: including rename, extract method, introduce variable, introduce
constant, pull up, push down and others
 Support for web frameworks: Django, web2py and Flask
 Integrated Python Debugger
 Integrated Unit Testing, with line-by-line code coverage
 Google App Engine Python Development
 Version Control Integration: unified user interface for Mercurial, Git, Subversion, Perforce
and CVS with changelists and merge

6.4 Qt PLATFORM

Qt is a cross-platform application framework that is used for developing application software that
can be run on various software and hardware platforms with little or no change in the underlying
codebase, while still being a native application with native capabilities and speed. Qt is currently
being developed both by The Qt Company, a company listed on the Nasdaq Helsinki Stock
Exchange, and the Qt Project under open-source governance, involving individual developers and
firms working to advance Qt.Qt is available with both commercial and open source GPL 2.0, GPL
3.0, and LGPL 3.0 licenses.

Qt - Code less, create more, Deploy everywhere

Purposes and abilities

Qt is used for developing multi-platform applications and graphical user interfaces (GUIs);
however, programs without a GUI can be developed, such as command-line tools and consoles for
servers. An example of a non-GUI program using Qt is the Cutelyst web framework.GUI programs
created with Qt can have a native-looking interface, in which case Qt is classified as a widget
toolkit.

Qt uses standard C++ with extensions including signals and slots that simplify handling of events,
and this helps in development of both GUI and server applications which receive their own set of
event information and should process them accordingly. Qt supports many compilers, including
the GCC C++ compiler and the Visual Studio suite. Qt also provides Qt Quick, that includes a
declarative scripting language called QML that allows using JavaScript to provide the logic. With
Qt Quick, rapid application development for mobile devices became possible, although logic can
be written with native code as well to achieve the best possible performance. Qt can be used in
several other programming languages via language bindings. It runs on the major desktop
platforms and some of the mobile platforms. It has extensive internationalization support. Non-
GUI features include SQL database access, XML parsing, JSON parsing, thread management and
network support.

Organizations using Qt

Qt is widely used by many organizations, including but not limited to European Space Agency,
DreamWorks, Lucasfilm, Panasonic, Philips, Samsung, Siemens, Volvo, Walt Disney Animation
Studios,Blizzard Entertainment, Electronic Arts, AMD, Valve Corporation.

Applications using Qt

 Notable applications using Qt or QML are:

 Adobe Photoshop Album
 Adobe Photoshop Elements
 AMD's Radeon Software Crimson Edition driver tool application.
 Autodesk Maya
 Bitcoin Core
  CryEngine
 Skype
 Spotify
 Telegram, a messaging client available for Windows, Mac and Linux
 VirtualBox OS virtualization software
 VLC media player
 WPS Office

Qt tools

Qt comes with its own set of tools to ease cross-platform development, which can otherwise be
cumbersome due to different set of development tools. Qt Creator is a cross-platform IDE for C++
and QML. Qt Designer's GUI layout/design functionality is integrated into the IDE, although Qt
Designer can still be started as a standalone tool.

In addition to Qt Creator, Qt provides qmake, a cross-platform build script generation tool that
automates the generation of Makefiles for development projects across different platforms.
Without such a tool, one would have to write different Makefiles for each platform, so it is useful
for abstracting away the differences of various platforms.

There are other tools available in Qt, including the Qt Designer interface builder and the Qt
Assistant help browser (which are both embedded in Qt Creator), the Qt Linguist translation tool,
uic (user interface compiler), and moc (Meta-Object Compiler).

6.5 Qt DESIGNER

Qt Designer is Qt's tool for designing and building graphical user interfaces (GUIs) from Qt
components. You can compose and customize your widgets or dialogs in a what-you-see-is-what-
you-get (WYSIWYG) manner, and test them using different styles and resolutions.

Widgets and forms created with Qt Designer integrated seamlessly with programmed code, using
Qt's signals and slots mechanism, that lets you easily assign behavior to graphical elements. All
properties set in Qt Designer can be changed dynamically within the code. Furthermore, features
like widget promotion and custom plugins allow you to use your own components with Qt
Designer.
 Qt Designer User Interface

Qt Designer's Editing Modes

Qt Designer provides four editing modes: Widget Editing Mode, Signals and Slots Editing Mode,
Buddy Editing Mode and Tab Order Editing Mode. When working with Qt Designer, you will
always be in one of these four modes. To switch between modes, simply select it from the Edit
menu or the toolbar. The table below describes these modes in further detail.

Qt Designer's Editing mode

Using Layouts in Qt Designer

Before a form can be used, the objects on the form need to be placed into layouts. This ensures
that the objects will be displayed properly when the form is previewed or used in an application.
Placing objects in a layout also ensures that they will be resized correctly when the form is resized.

The simplest way to manage objects is to apply a layout to a group of existing objects. This is
achieved by selecting the objects that you need to manage and applying one of the standard layouts
using the main toolbar, the Form menu, or the form's context menu.

Saving, Previewing and Printing Forms in Qt Designer

The preview shows exactly what the final component will look like when used in an application.

Since Qt 4.4, it is possible to preview forms with various skins - default skins, skins created with
Qt Style Sheets or device skins. This feature simulates the effect of calling
QApplication::setStyleSheet() in the application.

Using Containers in Qt Designer

Qt Designer provides visual feedback to help you place objects inside your containers. When you
drag an object from the widget box (or elsewhere) on the form, each container will be highlighted
when the cursor is positioned over it. This indicates that you can drop the object inside, making it
a child object of the container. This feedback is important because it is easy to place objects close
to containers without actually placing them inside. Both widgets and spacers can be used inside
containers.

6.6 AIRCRACK-NG SUITE

Aircrack-ng is a complete suite of tools to assess WiFi network security.

It focuses on different areas of WiFi security:

 Monitoring: Packet capture and export of data to text files for further processing by third
party tools.
 Attacking: Replay attacks, deauthentication, fake access points and others via packet
injection.
 Testing: Checking WiFi cards and driver capabilities (capture and injection).
  Cracking: WEP and WPA PSK (WPA 1 and 2).

All tools are command line which allows for heavy scripting. A lot of GUIs have taken advantage
of this feature. It works primarily Linux but also Windows, OS X, FreeBSD, OpenBSD, NetBSD,
as well as Solaris and even eComStation 2.

Aircrack-ng is a network software suite consisting of a detector, packet sniffer, WEP and
WPA/WPA2-PSK cracker and analysis tool for 802.11 wireless LANs. It works with any wireless
network interface controller whose driver supports raw monitoring mode and can sniff 802.11a,
802.11b and 802.11g traffic. The program runs under Linux, FreeBSD, OS X, OpenBSD, and
Windows; the Linux version is packaged for OpenWrt and has also been ported to the Android,
Zaurus PDA and Maemo platforms; and a proof of concept port has been made to the iPhone.

In April 2007 a team at the Darmstadt University of Technology in Germany developed a new
attack method based on a paper released on the RC4 cipher by Adi Shamir. This new attack, named
'PTW', decreases the number of initialization vectors or IVs needed to decrypt a WEP key and has
been included in the aircrack-ng suite since the 0.9 release.

Aircrack-ng is a fork of the original Aircrack project.

The aircrack-ng software suite includes:

Name Description

aircrack-ng Cracks WEP keys using the Fluhrer, Mantin and Shamir attack (FMS) attack, PTW
attack, and dictionary attacks, and WPA/WPA2-PSK using dictionary attacks.

airdecap- Decrypts WEP or WPA encrypted capture files with known key.
ng

airmon-ng Placing different cards in monitor mode.

aireplay-ng Packet injector (Linux, and Windows with CommView drivers).

airodump- Packet sniffer: Places air traffic into pcap or IVS files and shows information about
ng networks.
6.7 PyQt

PyQt is one of the two most popular Python bindings for the Qt cross-platform
GUI/XML/SQL C++ framework (another binding is PySide). PyQt developed by
Riverbank Computing Limited. Qt itself is developed as part of the Qt Project.
PyQt provides bindings for Qt 4 and Qt 5. PyQt is distributed under a choice of
licences: GPL version 2, GPL version 3, or a commercial license.

PyQt is available in two editions: PyQt4 which will build against Qt 4.x and 5.x and PyQt5 which
will only build against 5.x. Both editions can be built for Python 2 and 3. PyQt contains over 620
classes that cover graphical user interfaces, XML handling, network communication, SQL
databases, Web browsing and other technologies available in Qt.

PyQt IDE

The latest iteration of PyQt is v5.4. It fully supports Qt 5.4 which adds support for QtBluetooth,
QtPositioning, QtMacExtras, QtWinExtras and QtX11Extras.

PyQt implements around 440 classes and over 6,000 functions and methods including:
  a substantial set of GUI widgets
 classes for accessing SQL databases (ODBC, MySQL, PostgreSQL, Oracle, SQLite)
 QScintilla, Scintilla-based rich text editor widget
 data aware widgets that are automatically populated from a database
 an XML parser
 SVG support classes for embedding ActiveX controls on Windows (only in commercial
version)
 To automatically generate these bindings, Phil Thompson developed the tool SIP, which is
also used in other projects.

In August 2009, Nokia, the then owners of the Qt toolkit, released PySide, providing similar
functionality, but under the LGPL,after failing to reach an agreement with Riverbank Computing
to change its licensing terms to include LGPL as an alternative license.

PyQt main components

 PThe QtCore module contains the core non-GUI classes, including the event loop and Qt's
signal and slot mechanism. It also includes platform independent abstractions for Unicode,
threads, mapped files, shared memory, regular expressions, and user and application
settings.
 The QtGui module contains the majority of the GUI classes. These include a number of
table, tree and list classes based on the model–view–controller design pattern. Also
provided is a sophisticated 2D canvas widget capable of storing thousands of items
including ordinary widgets.
 The QtNetwork module contains classes for writing UDP and TCP clients and servers. It
includes classes that implement FTP and HTTP clients and support DNS lookups. Network
events are integrated with the event loop making it very easy to develop networked
applications.
 The QtOpenGL module contains classes that enable the use of OpenGL in rendering 3D
graphics in PyQt applications.yQt4 contains the following Python modules.
Applications that use PyQt

 OpenShot, a video editing program

 Anki, a spaced repetition flashcard program
 Dropbox, a file hosting service
 Eric Python IDE
 Kodos, Python Regular Expression Debugger
 Orange, a data mining and visualization framework
 qt-recordMyDesktop, Qt4 frontend for recordMyDesktop
 QGIS, a free software desktop Geographic Information Systems (GIS) application

6.8 SQLite

SQLite is a relational database management system contained in a C programming library. In

contrast to many other database management systems, SQLite is not a client–server database
engine. Rather, it is embedded into the end program.

SQLite is ACID-compliant and implements most of the SQL standard, using a dynamically and
weakly typed SQL syntax that does not guarantee the domain integrity.

SQLite is a popular choice as embedded database software for local/client storage in application
software such as web browsers. It is arguably the most widely deployed database engine, as it is
used today by several widespread browsers, operating systems, and embedded systems (such as
mobile phones), among others. SQLite has bindings to many programming languages.

Design

Unlike client–server database management systems, the SQLite engine has no standalone
processes with which the application program communicates. Instead, the SQLite library is linked
in and thus becomes an integral part of the application program. The library can also be called
dynamically. The application program uses SQLite's functionality through simple function calls,
which reduce latency in database access: function calls within a single process are more efficient
than inter-process communication. SQLite stores the entire database (definitions, tables, indices,
and the data itself) as a single cross-platform file on a host machine. It implements this simple
design by locking the entire database file during writing. SQLite read operations can be
multitasked, though writes can only be performed sequentially.

Due to the server-less design, SQLite applications require less configuration than client-server
databases. SQLite is called zero-conf because it does not require service management (such as
startup scripts) or access control based on GRANT and passwords. Access control is handled by
means of File system permissions given to the database file itself. Databases in client-server
systems use file system permissions which give access to the database files only to the daemon
process.

Features

SQLite implements most of the SQL-92 standard for SQL but it lacks some features. For example,
it partially provides triggers, and it can't write to views (however it provides INSTEAD OF triggers
that provide this functionality). While it provides complex queries, it still has limited ALTER
TABLE function, as it can't modify or delete columns.

SQLite uses an unusual type system for an SQL-compatible DBMS; instead of assigning a type to
a column as in most SQL database systems, types are assigned to individual values; in language
terms it is dynamically typed. Moreover, it is weakly typed in some of the same ways that Perl is:
one can insert a string into an integer column (although SQLite will try to convert the string to an
integer first, if the column's preferred type is integer). This adds flexibility to columns, especially
when bound to a dynamically typed scripting language. However, the technique is not portable to
other SQL products. A common criticism is that SQLite's type system lacks the data integrity
mechanism provided by statically typed columns in other products. The SQLite web site describes
a "strict affinity" mode, but this feature has not yet been added. However, it can be implemented
with constraints like CHECK(typeof(x)='integer')