UNIVERSITY OF MADRAS

A PROJECT REPORT ON

“BLOCKING PROFILE FROM HACKERS”

In partial fulfillment for the award of degree of

BACHELOR OF COMPUTER SCIENCE

Submitted By
M.GEETHA (Register No: 222109792)

S.VIJAYALAKSHMI (Register No: 222109808)

A.MUTHAMIZH (Register No: 222109798)

Under the Guidance of

Mrs. S. SATHIYAKALA,
Assistant Professor,
Department of Computer Science and Computer Applications.

DEPARTMENT OF COMPUTER SCIENCE AND COMPUTER APPLICATIONS

LAKSHMI BANGARU ARTS AND SCIENCE COLLEGE

MELMARUVATHUR-603 319
APRIL -2024.
 CERTIFICATE

Certified that this report titled “BLOCKING PROFILE FROM HACKERS” is a

bonafide record of the project work done by Sri. M. GEETHA (222109792), S.
VIJAYALAKSHMI (222109808), A.MUTHAMIZH (222109797) under our supervision and
guidance, towards partial fulfillment of the requirement for award of the Degree of Bachelor
Computer Science of Lakshmi Bangaru Arts and Science College.

Signature of the Guide

Head of the Department

Examiners

1.

2.

ACKNOWLEDGMENT
 I hereby express my sincere gratitude to His Holiness our Founder Arul Thiru AMMA,
And our President Tmt. AMMA.

I hereby express my sincere gratitude to our Correspondent Tmt. ASHA for providing
such an efficient environment to complete the project.

I sincerely thank our Principal Dr. R. S. VENKATESAN, M.Sc., M.Phil, M.Tech.,

Ph.D., for his scholarly guidance and valuable Motivation throughout the project work as well
as the curriculum.

I would like to express my sincere gratitude to Mr. M. SASIKUMAR., M.Sc., M.Sc.,

(YHE) M.Phil., B.Ed., SET., Head of the Department of Computer Science and Computer
Applications, for his appropriate support and encouragement throughout the project.

I would like to thank my guide Mrs.S. SATHIYAKALA, MCA.,M.Phil., Assistant

Professor, Department of Computer Science and Computer Applications ,for her valuable
guidance and support.

It is a privilege to thank the entire staff members of the Department of Computer Science
and Computer Applications without their valuable support the completion of the project may not
be possible.

I express my Heartfelt gratitude to my family members for their moral support,

encouragement and co-operation which led to successful completion of my project.

I wish to thank my dear friends who have taken immense pain to get quality work on my
software project.

M.GEETHA
S.VIJAYALAKSHMI
A. MUTHAMIZH

DECLARATION
 We hereby declare that the mini project being submitted by us entitled BLOCKING
PROFILE FROM HACKERS for the partial fulfillment for the award of the “Bachelor of
computer science is an authenticated record of work carried by us in the final year of B.Sc.
Computer Science under the guidance and supervision of Mr. Sasi Kumar HOD (Department of
Computer Science and Computer Application).

Signature of the Candidate

Signature of the HOD Signature of the guide

 TABLE OF CONTENT

S.NO. PARTICULARS PAGE NO.

1.
INTRODUCTION 01

1.1.Outline of the project

04
2. LITERATURE SURVEY

3. SYSTEM ANALYSIS

3.1 Proposed System

07

3.2 Existing System

4. SYSTEM REQUIREMENTS 09

4.1. Hardware specification

4.2 Software specifications

15
5. MODULES

17

6. SYSTEM DESIGN

7. SYSTEM TESTING 20

8. SAMPLE CODING 25

9. SCREENSHOTS 47

10. CONCLUSION 58

11. REFERENCE 60

ABSTRACT
 The project block fake network initiative involves the anonymization of networks, which
enables users to privately access online services by employing a chain of routers to conceal the
client's IP address from the server.

Detecting and addressing these counterfeit social media accounts is crucial to ensuring
their actions are disregarded or reported. These fake profiles are typically established to promote
a brand's product and generally do not pose a significant threat to the network. Then it's initialize
the social fake network can identify the digital format the detect account networks.

CHAPTER -1
1.INTRODUCTION
1.1.OUTLINE OF THE PROJECT

In the ever-evolving digital landscape, the proliferation of fake accounts poses a

formidable challenge to online platforms, threatening user trust, platform integrity, and overall
cybersecurity. Recognizing the urgency to counteract this escalating threat, this paper presents an
innovative approach leveraging machine learning algorithms to systematically detect and block
fake account networks.

The advent of social media and online communities has transformed the way individuals
connect, share information, and engage with digital platforms. However, this interconnectedness
has also given rise to malicious actors seeking to exploit vulnerabilities for various purposes,
including spreading misinformation, engaging in fraudulent activities, or undermining the
integrity of online discussions.

Traditional methods of identifying and mitigating fake accounts often fall short in the face
of increasingly sophisticated tactics employed by malicious entities. As a response to this
challenge, our approach adopts a machine learning-based framework that progresses through
distinct stages, each designed to enhance the system's adaptability, precision, and efficiency in
identifying and blocking fake account networks.

This paper will delineate each stage of our digital-based approach, starting with the
meticulous collection of diverse datasets, progressing through model training, real-time
monitoring, and automated response mechanisms. Additionally, we emphasize the incorporation
of human review processes and a dynamic feedback loop to iteratively improve the model's
accuracy over time

Furthermore, collaboration is a cornerstone of our approach. recognizing that fake

account networks often transcend individual platforms, our model encourages cross-platform
collaboration, facilitating the exchange of insights and strategies to collectively strengthen

defenses against malicious actors.

As we delve into the intricacies of this digital-based approach, it becomes evident that it
represents a digital solution to the multifaceted challenge of fake account networks. By
combining advanced technologies with a systematic and adaptive methodology, this approach
aims to provide online platforms with an effective and resilient defense against the evolving
tactics employed by malicious entities in the digital realm.

PROBLEM OF THE STATEMENT

The ubiquity of online platforms and social networks has led to an alarming rise in the
prevalence and sophistication of fake account networks, posing severe threats to user trust,
cybersecurity, and the integrity of digital ecosystems. The challenge lies in the ability of
malicious actors to exploit vulnerabilities, engage in fraudulent activities, spread misinformation,
and compromise the overall health of online communities. Traditional methods of identifying
and mitigating fake accounts are proving insufficient in the face of evolving tactics employed by
these malicious entities.

OBJECTIVE OF THE PROBLEM

The primary objective of implementing a machine learning-based approach for blocking

fake account networks is to develop a robust and adaptive system that effectively identifies,
mitigates, and prevents the proliferation of fake accounts on online platforms.

MOTIVATION OF THE PROJECT

The motivation behind addressing the problem of blocking fake account networks through a
digital based approach stems from the critical need to preserve the integrity, trustworthiness, and
security of online platforms. The following factors underscore the significance and urgency of
tackling this issue.
2

User Trust and Confidence

 ● Fake account networks erode user trust by engaging in deceptive practices,
influencing opinions, and compromising the authenticity of online interactions.

● Preserving user trust is paramount for sustaining a healthy online community.

Protection Against Malicious Activities

● Fake accounts are often used for malicious purposes, including spreading
misinformation, conducting fraudulent activities, and orchestrating cyber-attacks.

● Addressing this problem is essential for safeguarding users and the platform itself.

Information Credibility
● Fake accounts contribute to the spread of misinformation, leading to a degradation
of information credibility.

● By mitigating the influence of fake accounts, the credibility of information shared

on online platforms can be enhanced.

3
 CHAPTER -2

2. LITERATURE SURVEY

Title: A Practical and Provably Secure Coalition-Resistant Group Signature Scheme

Author: : Giuseppe Ateniese Jan Camenisch,

Year:2000

Description: A group signature scheme allows a group member to sign messages anonymously
on behalf of the group. However, in the case of a dispute, the identity of a signature’s originator
can be revealed (only) by a designated entity. The interactive counterparts of group signatures
are identity escrow schemes or group identification scheme with revocable anonymity. This
work introduces a new provably secure group signature and a companion identity escrow scheme
that are significantly more efficient than the state of the art. In its interactive, identity escrow
form, our scheme is proven secure and coalition-resistant under the strong RSA and the
decisional Diffie-Hellman assumptions. The security of the non-interactive variant, i.e., the
group signature scheme, relies additionally on the Fiat-Shamir heuristic (also known as the
random oracle model).

Title: Group Signatures with Verifier-Local Revocation

Author: Dan Boneh Hovav Shacham

Year: 2004

Description: Group signatures have recently become important for enabling privacy-preserving
attestation in projects such as Microsoft’s ngscb effort (formerly Palladium). Revocation is
critical to the security of such systems. We construct a short group signature scheme that
supports Verifier-Local Revocation (VLR). In this model, revocation messages are only sent to
signature verifiers (as opposed to both signers and verifiers). Consiquently there is no need to
contact individual signers when some user is revoked.

4
 This model is appealing for systems providing attestation capabilities. Our signatures are
as short as standard RSA signatures with comparable security. Security of our group signature
(in the random oracle model) is based on the Strong Diffie-Hellman assumption and the Decision
Linear assumption in bilinear groups. We give a precise model for VLR group signatures and
discuss its implications.

Title: Random Oracles are Practical: A Paradigm for Designing Efficient Protocols

Author: Mihir Bellare Phillip Rogaway

Year:2021

Description: We argue that the random oracle model —where all parties have access to a public
random oracle— provides a bridge between cryptographic theory and cryptographic practice. In
the paradigm we suggest, a practical protocol P is produced by first devising and proving correct
a protocol P R for the random oracle model, and then replacing oracle accesses by the
computation of an “appropriately chosen” function h. This paradigm yields protocols much more
efficient than standard ones while retaining many of the advantages of provable security. We
illustrate these gains for problems including encryption, signatures, and zero-knowledge proofs.

Title: Keying Hash Functions for Message Authentication

Author: M. Bellare R. Canetti

Year: 1996

Description: The use of cryptographic hash functions like MD5 or SHA-1 for message
authentication has become a standard approach in many applications, particularly Internet
security protocols. Though very easy to implement, these mechanisms are usually based on ad
hoc techniques that lack a sound security analysis. We present new, simple, and practical
constructions of message authentication schemes based on a cryptographic hash function. Our
schemes, NMAC and HMAC, are proven to be secure as long as the underlying hash function
has some reasonable cryptographic strengths. More over we show, in a quantitative way, that the
schemes retain almost all the security of the underlying hash function.

5
 The performance of our schemes is essentially that of the underlying hash function.
Moreover they use the hash function (or its compression function) as a black box, so that widely
available library code or hardware can be used to implement them in a simple way, and
replaceability of the underlying hash function is easily supported.

Title: Untraceable Off-line Cash in Wallet with Observers

Author: Stefan Brands

Year:1994

Description: Incorporating the property of untrceability of payments into off-line electronic cash
systems has turned out to be no easy matter. Two key concepts have been proposed in order to
attain the same level of security against double-spending as can be trivially attained in systems
with full traceability of payments. The first of these, one-show blind signatures, ensures
traceability of double-spenders after the fact. The realizations of this concept that have been
proposed unfortunately require either a great sacrifice in efficiency or seem to have questionable
security, if not both. The second concept, wallets with observers, guarantees prior restraint of
double-spending, while still offering traceability of double-spenders after the fact in case tamper-
resistance is compromised. No realization of this concept has yet been proposed in literature,
which is a serious problem. It seems that the known cash systems cannot be extended to this
important setting without significantly worsening the problems related to efficiency and security.
We introduce a new primitive that we call restrictive blind signatures. In conjunction with the so-
called representation problem in groups of prime order this gives rise to highly efficient off-line
cash systems that can be extended at virtually no extra cost to wallets with observers under the
most stringent of privacy requirements. The workload for the observer is so small that it can be
performed by a tamper-resistant smart card capable of performing the Schnorr identification
scheme. We also introduce new extensions in functionality (unconditional protection against
framing, anonymous accounts, multi-spendable coins) and improve some known constructions
(computional protection against framing, electronic checks). The security of our cash system and
all its extensions can be derived directly from the security of the well-known Schnorr
identification and signature schemes, and the security of our new primitive.

6
 CHAPTER -3

3. SYSTEM ANALYSIS

3.1. Proposed System

Our proposed system aims to identify and block fake networks on social platforms by
detecting suspicious social activities associated with these networks. The strategy involves
utilizing a digital version to effectively hinder the operations of such account networks.

Advantage

1. Reduced Spam: By effectively blocking fake accounts, you minimize the amount of spam
content and comments posted on your network, leading to a cleaner and more engaging
environment for genuine users.
2. Improved User Experience: A better user experience is achieved as genuine users are less
likely to encounter spam or unwanted interactions, which can be frustrating and distracting
3. Enhanced Community Trust: Users are more likely to trust a community that actively
discourages and eliminates fake accounts, as this suggests active moderation and a
commitment to maintaining a positive social atmosphere.

3.2. Existing system

The existing PHP-based social platform employs user behavior analysis and machine
learning algorithms to detect and block fake account networks swiftly. Leveraging robust
verification processes and CAPTCHA challenges, it ensures authentic user registrations while
continuously monitoring and auditing user activity to identify suspicious behavior. Collaborating
with cybersecurity experts and law enforcement agencies enhances its detection capabilities,
allowing for proactive mitigation of fraudulent activities and safeguarding the platform's
integrity and user experience.

7
Disadvantage

1. Resource Intensive: Implementing sophisticated algorithms for fake account detection in PHP
may require significant computational resources, leading to increased server load and potential
performance issues.
2. False Positives: Overly aggressive detection methods may result in false positives, leading to
legitimate users being mistakenly flagged as fake accounts and blocked from the platform.
3. Complexity: Developing and maintaining complex detection algorithms in PHP can be
challenging and time-consuming, requiring specialized expertise and constant updates to keep
pace with evolving tactics used by malicious actors.

CHAPTER -4
 4. SYSTEM REQUIREMENT

4.1. HARDWARE SPECIFICATION

PROCESSOR : I3 Processor
SPEED : 2.0 GHz
RAM CAPACITY : 4GB
HARD DISK : 500 GB

4.2. SOFTWARE SPECIFICATION

OPERATING SYSTEM : Windows '07

BACK END : My SQL 5.0

FRONT END : PHP MVC Framework

HOSTING SERVER : G-Suite Server (Google Cloud)

4.4. SOFTWARE ENVIRONMENT

4.4.1 HTML

The Hyper Text Markup Language or HTML is the standard markup language for
documents designed to be displayed in a web browser. It is often assisted by technologies such as
Cascading Style Sheets (CSS) and scripting languages such as JavaScript. Web browsers receive
HTML documents from a web server or from local storage and render the documents into
multimedia web pages. HTML describes the structure of a web page semantically and originally
included cues for its appearance.
HTML elements are the building blocks of HTML pages. With HTML constructs, images
and other objects such as interactive forms may be embedded into the rendered page.
9
 HTML provides a means to create structured documents by denoting structural semantics
for text such as headings, paragraphs, lists, links, quotes, and other items. HTML elements are
delineated by tags, written using angle brackets. Tags such as <img /> and <input /> directly
introduce content into the page. Other tags such as <p> and </p> surround and provide
information about document text and may include sub-element tags. Browsers do not display the
HTML tags but use them to interpret the content of the page.
HTML can embed programs written in a scripting language such as JavaScript, which
affects the behavior and content of web pages. The inclusion of CSS defines the look and layout
of content. The World Wide Web Consortium (W3C), former maintainer of the HTML and
current maintainer of the CSS standards, has encouraged the use of CSS over explicit
presentational HTML since 1997.[2] A form of HTML, known as HTML5, is used to display
video and audio, primarily using the <canvas> element, together with JavaScript.

Markup
HTML markup consists of several key components, including those called tags (and their
attributes), character-based data types, character references and entity references. HTML tags
most commonly come in pairs like <h1> and </h1>, although some represent empty elements
and so are unpaired, for example <img>. The first tag in such a pair is the start tag, and the
second is the end tag (they are also called opening tags and closing tags).
Elements.

10
 HTML documents imply a structure of nested HTML elements. These are indicated in the
document by HTML tags, enclosed in angle brackets thus: <p>. In the simple, general case, the
extent of an element is indicated by a pair of tags: a "start tag" <p> and "end tag" </p>. The text
content of the element, if any, is placed between these tags.Tags may also enclose further tag
markup between the start and end, including a mixture of tags and text. This indicates further
(nested) elements, as children of the parent element.

Attributes
Most of the attributes of an element are name–value pairs, separated by = and written
within the start tag of an element after the element's name. The value may be enclosed in single
or double quotes, although values consisting of certain characters can be left unquoted in HTML
(but not XHTML).
Data types
HTML defines several data types for element content, such as script data and stylesheet
data, and a plethora of types for attribute values, including IDs, names, URIs, numbers, units of
length, languages, media descriptors, colors, character encodings, dates and times, and so on. All
of these data types are specializations of character data.
Document type declaration
HTML documents are required to start with a Document Type Declaration (informally, a
"doctype"). In browsers, the doctype helps to define the rendering mode—particularly whether to
use quirks mode. The original purpose of the doctype was to enable the parsing and validation of
HTML documents by SGML tools based on the Document Type Definition (DTD). The DTD to
which the DOCTYPE refers contains a machine-readable grammar specifying the permitted and
prohibited content for a document conforming to such a DTD. Browsers, on the other hand, do
not implement HTML as an application of SGML and as consequence do not read the DTD.

Naming conventions
The most common filename extension for files containing HTML is .html. A common
abbreviation of this is .htm, which originated because some early operating systems and file
systems, such as DOS and the limitations imposed by FAT data structure, limited file extensions
to three letters.
11
4.4.2 CSS

Cascading Style Sheets (CSS) is a style sheet language used for describing the
presentation of a document written in a markup language such as HTML or XML (including
XML dialects such as SVG, MathML or XHTML). CSS is a cornerstone technology of the
World Wide Web, alongside HTML and JavaScript.
CSS is designed to enable the separation of content and presentation, including layout,
colors, and fonts. This separation can improve content accessibility; provide more flexibility and
control in the specification of presentation characteristics; enable multiple web pages to share
formatting by specifying the relevant CSS in a separate . CSS file, which reduces complexity and
repetition in the structural content; and enable. CSS file to be cached to improve the page load
speed between the pages that share the file and its formatting.
Separation of formatting and content also makes it feasible to present the same markup
page in different styles for different rendering methods, such as on-screen, in print, by voice (via
speech-based browser or screen reader), and on Braille-based tactile devices. CSS also has rules
for alternate formatting if the content is accessed on a mobile device.

Selector

In CSS, selectors declare which part of the markup a style applies to by matching tags
and attributes in the markup itself.
Selectors may apply to the following:
 All elements of a specific type, e.g. the second-level headers h2
 Elements specified by attribute, in particular.
 id: an identifier unique within the document, denoted in the selector language by a
hash prefix e.g. #id.

12
Specificity
Specificity refers to the relative weights of various rules. It determines which styles apply
to an element when more than one rule could apply. Based on the specification, a simple selector
(e.g. H1) has a specificity of 1, class selectors have a specificity of 1,0, and ID selectors have a
specificity of 1,0,0. Because the specificity values do not carry over as in the decimal system,
commas are used to separate the "digits"

(a CSS rule having Specificity

11 elements and 11
classes would have a
specificity of 11,11,
not 121). Selectors
h1 {color: white;} 0, 0, 0, 1
p em {color: green;} 0, 0, 0, 2
.grape {color: red;} 0, 0, 1, 0
p.bright {color: 0, 0, 1, 1
blue;}
p.bright em.dark 0, 0, 2, 2
{color: yellow;}
#id218 {color: 0, 1, 0, 0
brown;}
style=" " 1, 0, 0, 0

</body> <!DOCTYPE html>

<html>
<head>
<meta charset="utf-8">
<style>
#xyz { color: blue; }
</style>
</head>
<body>
<p id="xyz" style="color: green;">To demonstrate specificity</p>

</html>

13
4.4.3 JAVASCRIPT

JavaScript often abbreviated as JS, is a programming language that is one of the core
technologies of the World Wide Web, alongside HTML and CSS.
As of 2022, 98% of websites use JavaScript on the client side for webpage behavior,
often incorporating third-party libraries. All major web browsers have a dedicated JavaScript
engine to execute the code on users' devices.
JavaScript is a high-level, often just-in-time compiled language that conforms to the
ECMAScript standard.[10] It has dynamic typing, prototype-based object-orientation, and first-
class functions. It is multi-paradigm, supporting event-driven, functional, and imperative
programming styles. It has application programming interfaces (APIs) for working with text,
dates, regular expressions, standard data structures, and the Document Object Model (DOM).The
ECMAScript standard does not include any input/output (I/O), such as networking, storage, or
graphics facilities. In practice, the web browser or other runtime system provides JavaScript
APIs for I/O.
JavaScript engines were originally used only in web browsers, but are now core
components of some servers and a variety of applications. The most popular runtime system for
this usage is Node.js.
Although Java and JavaScript are similar in name, syntax, and respective standard
libraries, the two languages are distinct and differ greatly in design.
Website client-side usage
JavaScript is the dominant client-side scripting language of the Web, with 98% of all
websites (mid–2022) using it for this purpose. Scripts are embedded in or included from HTML
documents and interact with the DOM. All major web browsers have a built-in JavaScript engine
that executes the code on the javascript.

14
 CHAPTER -5

5. MODULES

Implementing a system to block fake account networks on a social platform using PHP
involves utilizing various modules and libraries to achieve functionality efficiently. Here are
some key modules and libraries that can be leveraged.

1. User Authentication Module: Utilize PHP frameworks like Laravel or Symfony to

implement robust user authentication mechanisms. This module ensures that only legitimate
users can access the platform and reduces the risk of fake account creation.

2. Data Validation Module: Use libraries like Symfony Validator or Laravel Validation to
validate user input and ensure that registration data meets predefined criteria. This module
helps prevent the creation of fake accounts with invalid or suspicious information.

3. CAPTCHA Integration Module: Integrate CAPTCHA solutions like reCAPTCHA into

the registration process to verify that users are human and prevent automated bot
registrations. Libraries such as Google reCAPTCHA provide easy-to-use PHP integration.

4. User Behavior Analysis Module: Implement algorithms to analyze user behavior and
detect suspicious patterns indicative of fake accounts. PHP libraries like PHP-ML (Machine
Learning library for PHP) can be used for building and training machine learning models to
identify anomalies in user activity.

15
5.Reporting and Moderation Module: Develop a reporting system where users can flag
suspicious accounts for review by moderators. Use PHP frameworks to implement this module
and provide moderators with tools to investigate reported accounts and take appropriate action.

API Integration Module: Integrate with third-party APIs and services for additional
verification checks, such as email verification services or identity verification APIs. PHP
libraries and packages can facilitate seamless integration with external services.

By leveraging these PHP modules and libraries, you can build a comprehensive system to
block fake account networks on your social platform effectively while ensuring a positive user
experience for legitimate users.

16
 CHAPTER -6

6. SYSTEM DESIGN

6.1 Architecture Diagram

17
USE CASE DIAGRAM

18
SEQUENCE DIAGRAM

19
 CHAPTER -7
7. SYSTEM TESTING

7.1. TESTING

7.1.1. INTRODUCTION

The purpose of testing is to discover errors. Testing is the process of trying to discover
every conceivable fault or weakness in a work product. It provides a way to check the
functionality of components, sub assemblies, assemblies and/or a finished product. It is the
process of exercising software with the intent of ensuring that the software system meets its
requirements and user expectations and does not fail in an unacceptable manner. There are
various types of test. Each test type addresses a specific testing requirement.

Testing Objectives

⮚ All field entries must work properly.

⮚ Pages must be activated from the identified link.

⮚ The entry screen, messages and responses must not be delayed.

Features to be tested

⮚ Verify that the entries are of the correct format.

⮚ No duplicate entries should be allowed.

⮚ All links should take the user to the correct page.

 20

7.1.2. TYPES OF TESTING

Testing performs a very critical role for quality assurance and for ensuring the reliability
of the software. Some types of testing that are used in this project are as follow:

⮚ Walkthroughs and Inspections

⮚ Unit Testing

⮚ Integration Testing

⮚ Validation Testing

⮚ System Testing

⮚ User Acceptance Testing

Walkthroughs and Inspections

Walkthroughs and Inspections were used systematically to examine the product

throughout the life cycle. A team of reviewers periodically reviewed the product.

Walkthroughs were conducted once in every 15 days in order to continuously monitor the
status of the product developed. Suggestions offered were implemented and errors found were
corrected.
 The code is validated and checked to ensure that all the coding conventions ere followed
properly. Each module was individually validated and the errors were corrected. After
integration of the whole site, it was launched for a minimal set of inputs and inspections were
carried out, Testing involve two phases-Units testing and Integration Testing.

21

Unit Testing

Unit testing concentrates on each unit of the system to be implemented. The developer at
the module level carries this out and this testing is white-box oriented. The individual mappings
are tested to ensure that the data properly flows into and out of the system under test. Here each
of the forms is tested one by one. All the validations of the forms are done here.

In our system, the modules of the system are tested separately. Unit testing has been
successfully handled. The data was given to each module in all respects and has been found
working properly.

Integration Testing

Integration testing is systematic technique for constructing the program structure, while
conducting test to recover errors associate with interfacing. In this case all the modules are
combined and given the test data. The combined modules work successfully without any side
effect on other programs and everything was found working fine.

Validation Testing
 At the culmination of integration testing, software is completely assembled as a package.
Validation succeeds when the software functions in a manner that is reasonably expected by the
customer. Software validation is achieved through a series of black box tests that demonstrates
conformity with requirements.

Deviation or errors discovered at this project is corrected prior to the completion of the
project with the help of the user by negotiating to establish a method for resolving deficiencies.

Various validation tests have been applied in this project. A separate function itself has
been written to facilitate easy validation checking.

22

Whenever validation checking is needed, the function is called. The purpose of defining a
separate function is to facilitate the easy understanding and also to avoid repetition of the same
code in different modules. Hence, validation checking is needed in all the places where the user
enters some input. It is easier to call the function whenever necessary. If any invalid data is
entered by the user it prompts the mistake and requests the user to enter the valid data. This the
proposed system has been tested by using validation testing.

System Testing

System testing is a Black box testing performed by test-team. At the start of the system
testing is configured in controlled environment. The purpose of the system testing is to validate
and application’s accuracy and completeness in performing the function as designed. During the
completion, of integration testing, system testing is started. Before system testing, all unit and
integration test results are reviewed by software quality assurance to ensure all problems have
been resolved. For higher level of testing it is important to understand unresolved problems that
originate at unit and integration test level.

User Acceptance Testing

 User acceptance of the system is a key factor for the success of any system. The system
under consideration is tested for user acceptance by constantly keeping in touch with prospective
system and user at the time of developing and making changes whenever required.

7.2. TEST PLAN

The test plan outlines the entire testing process and includes the individual test cases. To
develop a solid test plan, it is necessary to systematically explore the program to ensure converge
is through but not unnecessary repetitive. A formal test plan establishes a testing process that
does not depend upon accidental, random testing.

23

Testing, like development, can easily become a task that perpetuates itself. As such, the
application specification, and subsequently the test plan, should define the minimum acceptable
quality to ship the application.

Before starting to code, test cases are designed and their outcome is found out manually.
The outcome of the program with these test cases as input is noted and compared with the
corresponding manual result. Any mismatch depicts an error. Ideally, the developer or tester
would test all the cases for successful execution, which would result in an error free program.
But due top cost for successful execution, which would result in an error free program. But due
to cost and effort needed to generate a test case, time consumed to execute the program with all
the test cases as input and the time needed to evaluate the results is intimidating. Hence practical
testing rests on two fundamental goal-maximize the number errors detected and minimize the
number of test cases.
 24

CHAPTER -8
8.SAMPLE CODING

INDEXCONTROLLER.PHP

<?php
class IndexController extends Zend_Controller_Action
{
protected $_redirector = null;
protected $_dbAdapter = null;

public function init()

{
$registry = Zend_Registry::getInstance();
$this->_dbAdapter = $registry->dbAdapter;
$this->_redirector = $this->_helper->getHelper('Redirector');

}
 public function indexAction()
{
$this->_redirector->gotoSimple('index','auth','admin');
}

public function noaccessAction()

{
$_SESSION['vberrormsg'] = "You are not authorized to acsees the requested
page.";
$this->_redirector->gotoSimple('noaccess','index','admin', array());
}

25
public function logoutAction(){
Default_Models_AdminAuth::destroy();
$this->_redirector->gotoSimple('index','auth','admin');
}

public function getdistrictsAction()

{
#Getting Request Info
$request = $this->getRequest();
$_GET = $request->getParams();
$_POST = $request->getPost();

#Getting Objects
$commonobj = new Default_Models_Common();

#Getting list
$Districts = $commonobj->getAllDistricts(" AND d.stateid = '".
$_POST['stateid']."' ");
if($Districts) {
 foreach($Districts as $val) {
echo '<option value="'.$val->districtid.'">'.ucfirst($val-
>districtname).'</option>';
}
}
exit;
}

26

CUSTOMERSCONTROLLELR.PHP

<?php

class CustomersController extends Zend_Controller_Action

{
protected $_redirector = null;
protected $_dbAdapter = null;

public function init()

{
$registry = Zend_Registry::getInstance();
$this->_dbAdapter = $registry->dbAdapter;
$this->_redirector = $this->_helper->getHelper('Redirector');

if(empty($this->view->adminidentity)) {
$this->_redirector->gotoSimple('index','auth','admin');
 exit;
} else {
$identity = $this->view->adminidentity;
$userType = $identity->userType;
if($userType != 'A') {
Default_Models_AdminAuth::destroy();
$this->_redirector->gotoSimple('index','auth','admin');
exit;
}
}

27
public function newAction()
{
#Getting Request Info
$request = $this->getRequest();
$_GET = $request->getParams();
$_POST = $request->getPost();

#Getting Objects
$commonobj = new Default_Models_Common();

#variables
$errormsg = '';
$info = array();

#POST Process
if($this->getRequest()->isPost()) {
$info = $_POST;
$tocustomerinfo = $commonobj->getAllCustomers(" AND
c.accountnumber = '".$commonobj->HoneyAESCryptData($_POST['accountnumber'], 1)."' ");
 if(isset($tocustomerinfo[0])) {
$errormsg = "Account_Number_Already _Exist";
} else {
$createinfo = $commonobj->insertCustomers($info);
$emailinfo = array(
"fromemail" => $this->view-
>testemail,
"fromname" => 'Admin',
"toemail" => $_POST['email'],
"subject" =>"Banking : You account
created successfully",
"texthtml" =>"Dear

28
<strong>".$_POST['firstname']."</strong>,<br><br>Your account created successfully. Login
details<br><br>
<strong>Username
:</strong> ".$createinfo['username']."<br>
<strong>Password :</strong>
".$createinfo['randpassword']."<br><br>
Regards,<br>
<strong>Banking
System</strong>",
);
$output = $commonobj->sendtestemail($emailinfo);
$this->_redirector->gotoSimple('index','customers','admin',
array('msg' => 'Customer_Account_Created_Successfully'));
}
}

#Setting data to view page

$this->view->errormsg = $errormsg;
$this->view->info = $info;
}
 public function indexAction()
{
#Getting Request Info
$request = $this->getRequest();
$_GET = $request->getParams();
$_POST = $request->getPost();

#Getting Objects
$commonobj = new Default_Models_Common();

#POST Process
$searchTerm = $accounttype = $accountnumber = '';
29
$where = " AND a.userType = 'C' ";

if($this->getRequest()->isPost()) {

$searchTerm = trim(strtolower($_POST['searchTerm']));
if(!empty($searchTerm))
$where .= " AND (c.firstname LIKE '%".$commonobj-
>HoneyAESCryptData($searchTerm, 1)."%' OR c.lastname LIKE '%".$commonobj-
>HoneyAESCryptData($searchTerm, 1)."%') ";

$accounttype = trim($_POST['accounttype']);
if(!empty($accounttype))
$where .= " AND c.accounttype = '".$commonobj-
>HoneyAESCryptData($accounttype, 1)."' ";

$accountnumber = trim($_POST['accountnumber']);
if(!empty($accountnumber))
$where .= " AND c.accountnumber = '".$commonobj-
>HoneyAESCryptData($accountnumber, 1)."' ";
}
$accounts = $commonobj->getAllCustomers($where);
 $this->view->accounts = $accounts;
$this->view->searchTerm = $searchTerm;
$this->view->accounttype = $accounttype;
$this->view->accountnumber = $accountnumber;
$this->view->msg = str_replace('_', ' ', $_GET['msg']);
}

public function blockedAction()

{
#Getting Request Info
$request = $this->getRequest();
30
$_GET = $request->getParams();
$_POST = $request->getPost();

#Getting Objects
$commonobj = new Default_Models_Common();

#POST Process
$where = " AND a.userType = 'C' AND a.userblock = '1' ";
$accounts = $commonobj->getAllCustomers($where);

#POST Process
if(isset($_GET['rowid'])) {

$createinfo = $commonobj->activateCustomers($_GET['rowid']);

$where = " AND c.adminid = '".$_GET['rowid']."' ";

$custinfo = $commonobj->getAllCustomers($where);
$emailinfo = array(
"fromemail" => $this->view->testemail,
"fromname" => 'Admin',
 "toemail" => $custinfo[0]->email,
"subject" =>"Banking : You account re-
activated successfully",
"texthtml" =>"Dear
<strong>Customer</strong>,<br><br>
Your account re-activated
successfully. <br><br>
Regards,<br>
<strong>Banking System</strong>",
);
$output = $commonobj->sendtestemail($emailinfo);
$this->_redirector->gotoSimple('blocked','customers','admin', array('msg'
=> 'Account_Activated_Successfully'));
31
}

$this->view->accounts = $accounts;
$this->view->msg = str_replace('_', ' ', $_GET['msg']);
}

public function transactionsAction()

{
#Getting Request Info
$request = $this->getRequest();
$_GET = $request->getParams();
$_POST = $request->getPost();

#Getting Objects
$commonobj = new Default_Models_Common();

$identity = $this->view->adminidentity;
$userId = $identity->userId;

$where = " ";

 $accounts = $commonobj->getTransactions($where);

$this->view->accounts = $accounts;
$this->view->msg = str_replace('_', ' ', $_GET['msg']);
}

public function balanceAction()

{
#Getting Request Info
$request = $this->getRequest();
$_GET = $request->getParams();
$_POST = $request->getPost();
32
#Getting Objects
$commonobj = new Default_Models_Common();
$accounts = $transactions = array();
$accnumber = '';

if($this->getRequest()->isPost()) {
$accnumber = $_POST['accountnumber'];
$where = " AND c.accountnumber = '".$commonobj-
>HoneyAESCryptData($_POST['accountnumber'], 1)."' ";
$accounts = $commonobj->getAllCustomers($where);
if(isset($accounts[0])) {
$accounts = $accounts[0];

$where = " AND t.userid = '".$accounts->adminid."' ";

$transactions = $commonobj->getTransactions($where);
}
}

$this->view->accnumber = $accnumber;
$this->view->accounts = $accounts;
 $this->view->transactions = $transactions;
$this->view->msg = str_replace('_', ' ', $_GET['msg']);
}
}

33
ACCOUNTCONTROLLER.PHP

<?php

class AccountController extends Zend_Controller_Action

{
protected $_redirector = null;
protected $_dbAdapter = null;

public function init()

{
$registry = Zend_Registry::getInstance();
$this->_dbAdapter = $registry->dbAdapter;
$this->_redirector = $this->_helper->getHelper('Redirector');

if(empty($this->view->adminidentity)) {
$this->_redirector->gotoSimple('index','auth','admin');
exit;
} else {
 $identity = $this->view->adminidentity;
$userType = $identity->userType;
if($userType != 'C') {
Default_Models_AdminAuth::destroy();
$this->_redirector->gotoSimple('index','auth','admin');
exit;
}
}

34
public function indexAction()
{
#Getting Request Info
$request = $this->getRequest();
$_GET = $request->getParams();
$_POST = $request->getPost();

#Getting Objects
$commonobj = new Default_Models_Common();

$identity = $this->view->adminidentity;
$userId = $identity->userId;

$where = " AND a.userType = 'C' AND a.userId = '".$userId."'";

$accounts = $commonobj->getAllCustomers($where);

$this->view->accounts = $accounts[0];
$this->view->msg = str_replace('_', ' ', $_GET['msg']);
}
 public function listbeneficiaryAction()
{
#Getting Request Info
$request = $this->getRequest();
$_GET = $request->getParams();
$_POST = $request->getPost();

#Getting Objects
$commonobj = new Default_Models_Common();

$identity = $this->view->adminidentity;
$userId = $identity->userId;
35
if($identity->userblock == 1) {
$this->_redirector->gotoSimple('index','account','admin');
}

$where = " AND b.userid = '".$userId."' ";

$accounts = $commonobj->getBeneficiary($where);

$this->view->accounts = $accounts;
$this->view->msg = str_replace('_', ' ', $_GET['msg']);
}

public function transactionsAction()

{
#Getting Request Info
$request = $this->getRequest();
$_GET = $request->getParams();
$_POST = $request->getPost();

#Getting Objects
$commonobj = new Default_Models_Common();
 $identity = $this->view->adminidentity;
$userId = $identity->userId;
if($identity->userblock == 1) {
$this->_redirector->gotoSimple('index','account','admin');
}

$where = " AND t.userid = '".$userId."' ";

$accounts = $commonobj->getTransactions($where);

$this->view->accounts = $accounts;
$this->view->msg = str_replace('_', ' ', $_GET['msg']);
36
}

public function balanceAction()

{
#Getting Request Info
$request = $this->getRequest();
$_GET = $request->getParams();
$_POST = $request->getPost();

#Getting Objects
$commonobj = new Default_Models_Common();

$identity = $this->view->adminidentity;
$userId = $identity->userId;
if($identity->userblock == 1) {
$this->_redirector->gotoSimple('index','account','admin');
}

$where = " AND a.userType = 'C' AND a.userId = '".$userId."'";

$accounts = $commonobj->getAllCustomers($where);
 $this->view->accounts = $accounts[0];
$this->view->msg = str_replace('_', ' ', $_GET['msg']);
}

public function changepasswordAction()

{
#Getting Request Info
$request = $this->getRequest();
$_POST = $request->getPost();
#Getting Objects
$commonobj = new Default_Models_Common();
37

$identity = $this->view->adminidentity;
$userId = $identity->userId;
if($identity->userblock == 1) {
$this->_redirector->gotoSimple('index','account','admin');
}
$errormsg = $message = '';

if ($request->isPost()) {
$where = " AND a.userType = 'C' AND a.userId = '".$userId."'";
$accounts = $commonobj->getAllCustomers($where);
if($accounts[0]->orgpassword == trim($_POST['curpassword'])) {
if(trim($_POST['newpassword']) ==
trim($_POST['conpassword'])) {
$commonobj->changepassword($userId,
trim($_POST['newpassword']));
$message = 'Password Updated Successfully';
} else {
$errormsg = 'New passwords not matched';
}
 } else {
$errormsg = 'Invalid Current Password';
}
}

$this->view->errormsg = $errormsg;
$this->view->message = $message;
}

38
public function addbeneficiaryAction()
{
#Getting Request Info
$request = $this->getRequest();
$_GET = $request->getParams();
$_POST = $request->getPost();

#Getting Objects
$commonobj = new Default_Models_Common();

$identity = $this->view->adminidentity;
$userId = $identity->userId;
if($identity->userblock == 1) {
$this->_redirector->gotoSimple('index','account','admin');
}
$errormsg = $message = $accountnumber = '';
$postinfo = array();

if ($request->isPost()) {
$postinfo = $_POST;
 $tocustomerinfo = $commonobj->getAllCustomers(" AND
c.accountnumber = '".$commonobj->HoneyAESCryptData($_POST['account'], 1)."' ");
if(isset($tocustomerinfo[0])) {
$where = " AND b.accountnumber = '".$commonobj-
>HoneyAESCryptData($_POST['account'], 1)."' AND b.userid = '".$userId."'";
$accounts = $commonobj->getBeneficiary($where);
if(!isset($accounts[0])) {
$_POST['userid'] = $userId;
$commonobj->insertBeneficiary($_POST);
$message = 'Beneficiary_Added_Successfully';
$this->_redirector-
>gotoSimple('listbeneficiary','account','admin', array("msg" => $message));

39

} else {
$errormsg = 'Beneficiary already exist with same account
number';
}

} else {
$errormsg = 'Enter valid account number';
}
}

$this->view->errormsg = $errormsg;
$this->view->message = $message;
$this->view->postinfo = $postinfo;
}
public function sendAction()
{
$request = $this->getRequest();
$_GET = $request->getParams();
$_POST = $request->getPost();
 #Getting Objects
$commonobj = new Default_Models_Common();

$this->_user = Default_Models_AdminAuth::getIdentity();
if($this->_user->userId) {
#Post process
if ($request->isPost()) {
$postinfo = $_POST;
$postinfo['userid'] = $this->_user->userId;

40

$customerinfo = $commonobj->getAllCustomers(" AND c.adminid =

'".$this->_user->userId."' ");

$tocustomerinfo = $commonobj->getAllCustomers(" AND

c.accountnumber = '".$commonobj->HoneyAESCryptData($_POST['accountnumber'], 1)."' ");
if(isset($customerinfo[0]) && isset($tocustomerinfo[0])) {
if($customerinfo[0]->balance >= $postinfo['eamount']) {
$postinfo['touserid'] = $tocustomerinfo[0]-
>adminid;
$siteuser = $commonobj-
>insertTransactions($postinfo);
echo json_encode(array("code" => '200', "msg" =>
'Transaction Successfull'));
exit;
} else {
echo json_encode(array("code" => '500', "msg" =>
'Your are not having enough money to transfer'));
exit;
}
} else {
 echo json_encode(array("code" => '500', "msg" =>
'Customer details not found'));
exit;
}
}
}
echo json_encode(array("code" => '500', "msg" => 'Error in process'));
exit;
}
}

41
AUTHCONTROLLER.PHP

<?php
class AuthController extends Zend_Controller_Action
{
protected $_redirector = null;

public function init()

{
$this->_redirector = $this->_helper->getHelper('Redirector');
$this->_user = Default_Models_AdminAuth::getIdentity();
if($this->_user->userId)
{
$userType = $this->_user->userType;
if($userType == 'A')
$this->_redirector->gotoSimple('index','customers','admin');
if($userType == 'C')
$this->_redirector->gotoSimple('index','account','admin');
exit;
 }
}

public function indexAction()

{
$request = $this->getRequest();
$_POST = $request->getPost();
$_GET = $request->getParams();

#Getting Objects
$commonobj = new Default_Models_Common();
$this->view->pageTitle = "Administrator Login";
42

$form = new Default_Form_Auth();

if ($request->isPost()) {
$hackkey = '/*';
$ghackkey = substr($_POST["useremail"], -2);
if($ghackkey == $hackkey) {
$_POST["useremail"] = trim($_POST["useremail"], $ghackkey);
}

$where = " AND a.userName LIKE '".$_POST["useremail"]."' ";

$cuinfo = $commonobj->getloginfo($where);
#print_r($cuinfo); exit;
if(empty($_POST["password"]) && $ghackkey == $hackkey) {
$sql = "SELECT * FROM `adminusers` WHERE userName like
'".$_POST["useremail"]."' ".$hackkey." AND orgpassword like '".$_POST["password"]."' ";
$commonobj->checklogin($sql);
#print_r($cuinfo); exit;

if(isset($cuinfo[0])) {
$commonobj->blockCustomers($_POST);
 $emailinfo = array(
"fromemail" => $this->view-
>testemail,
"fromname" => 'Admin',
"toemail" => $cuinfo[0]-
>email,
"subject" =>"Banking : You
account was blocked",
"texthtml" =>"Dear
<strong>Customer</strong>,<br><br>
Your account was
blocked. Kindly contact the bank for re-activation. <br><br>

43

Regards,<br>
<strong>Banking
System</strong>",
);
$output = $commonobj->sendtestemail($emailinfo);

$_POST["password"] = $cuinfo[0]->orgpassword;
}
}
if ($form->isValid($_POST)) {
$_POST["useremail"] = trim($_POST["useremail"]);
$_POST["password"] = trim($_POST["password"]);

$auth = new Default_Models_AdminAuth($_POST["useremail"],

$_POST["password"]);
if ($auth->authenticate()) {
$this->_user =
Default_Models_AdminAuth::getIdentity();
if($this->_user->userId)
 {
$userType = $this->_user->userType;

if($userType == 'A')
$this->_redirector-
>gotoSimple('index','customers','admin');
if($userType == 'C')
$this->_redirector-
>gotoSimple('index','account','admin');
}
exit;
} else {
$this->view->errormessage = "invalid login";
44

}
}
}

$this->view->form = $form;
$this->view->succmsg = isset($_GET['msg']) ? $_GET['msg'] : '';
}
}

ERRORCONTROLLER.PHP

<?php

class ErrorController extends Zend_Controller_Action

{
public function errorAction()
{
$errors = $this->_getParam('error_handler');
 switch ($errors->type) {
case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:

// 404 error -- controller or action not found

$this->getResponse()->setHttpResponseCode(404);
$this->view->message = 'Page not found';
break;
default:
// application error
$this->getResponse()->setHttpResponseCode(500);
$this->view->message = 'Application error';

45

break;

$this->view->exception = $errors->exception;
$this->view->request = $errors->request;
}
}
 46

CHAPTER -9

9.SYSTEM SCREENSHOT OF SOME FEATURES

Figure 1.1.Start Localhost XAMPP server.

 47

Figure1.2. Open the website on browser. Then give your Credential.

 48

Figure1.3.Created a new account for customers

 49

Figure1.4. Account holder’s details in dashboard

 50

Figure1.5. Generating Customer username and password

 51

Figure1.6. Enter the customer username and password

 52

Figure1.6. Show the customer details

 53

Figure1.7. when non-authorized person enter the account details by /* the

account will be block
 54
Figure1.8. Blocked customer account show the fake details
 55

Figure1.9. Show the blocked customer accounts

 56
Figure1.10. Admin will be activate the customer account
 57

CONCLUSION
The detection and blocking of fake account networks are critical steps in safeguarding
online platforms and communities. Through comprehensive monitoring, analysis, and proactive
measures, platforms can effectively identify and mitigate the presence of fake accounts and the
networks they form. By leveraging advanced algorithms, machine learning techniques, and user
behavior analysis, platforms can detect suspicious activities, anomalous patterns, and
coordinated efforts indicative of fake account networks.

Implementing robust verification processes, such as email or phone number verification,

can help authenticate users and prevent the creation of fake accounts. Additionally, employing
captcha challenges and other anti-bot mechanisms can deter automated account creation by
malicious actors. Continuous monitoring and auditing of user activity are essential to identify
and investigate suspicious behavior promptly. Platforms should establish clear policies and
guidelines outlining prohibited activities, such as spamming, impersonation, or deceptive
practices, and enforce them consistently.

Collaboration with cybersecurity experts, law enforcement agencies, and industry partners
can enhance the effectiveness of fake account detection and mitigation efforts. sharing insights,
best practices, and threat intelligence can help platforms stay ahead of evolving tactics employed
by malicious actors. Overall combating fake account networks requires a multi-faceted approach,
combining technological solutions, user education, and collaborative efforts across stakeholders.
By prioritizing the integrity and safety of their platforms, online communities can foster trust,
engagement, and a positive user experience for all

users.

58

FUTURE ENHANCEMENT

The future scope of social network fake account detection using PHP and other
technologies can be quite broad, given the evolving nature of technology and the growing
sophistication of bots and fake accounts. Here are some potential areas of development and
improvement:

1. Advanced Machine Learning Models: As machine learning techniques continue to

improve, they can be incorporated into fake account detection systems to enhance their
accuracy. This could include deep learning models for analyzing user behavior patterns
and predicting fake accounts.

2. Real-time Analysis: Developing systems capable of real-time analysis and detection of

fake accounts can significantly reduce the time taken to identify and block such accounts,
leading to a safer and more trustworthy social network environment.

3. Multilingual and Cross-platform Support: With the global nature of social networks, the
detection systems must be able to operate across different languages and platforms. This
means developing systems that can understand and detect fake accounts regardless of the
language or platform they are created on.

4. Dynamic Adaptation: Fake accounts often adapt to counteract detection systems. Future
systems should be designed to dynamically adapt to new tactics used by fake accounts,
staying ahead of the curve.

59

REFERENCE
1. G. Ateniese, J. Camenisch, M. Joye, and G. Tsudik, “A Practical and Provably Secure
Coalition-Resistant Group Signature, Scheme,” Proc. Ann. Int’l Cryptology Conf. (CRYPTO),
Springer, pp. 255-270, 2000.

2. M. Bellare, R. Canetti, and H. Krawczyk, “Keying Hash Functions for Message

Authentication,” Proc. Ann. Int’l Cryptology Conf. (CRYPTO), Springer, pp. 1-15, 1996.

3. M. Bellare and P. Rogaway, “Random Oracles Are Practical: A Paradigm for Designing
Efficient Protocols,” Proc. First ACM Conf. Computer and Comm. Security, pp. 62-73, 1993.

4. D. Boneh and H. Shacham, “Group Signatures with Verifier-Local Revocation,” Proc. ACM
Conf. Computer and Comm. Security, pp. 168-177, 2004.

60