ABSTRACT

Digital fingerprinting is a technique to deter unauthorized redistribution of multimedia

content by embedding a unique identifying signal in each legally distributed copy. The
embedded fingerprint can later be extracted and used to trace the originator of an
unauthorized copy. A group of users may collude and attempt to create a version of the
content that cannot be traced back to any of them. As multimedia data is commonly stored
in compressed form, this paper addresses the problem of fingerprinting compressed
signals. Analysis is carried out to show that due to the quantized nature of the host signal
and the embedded fingerprint, directly extending traditional fingerprinting techniques for
uncompressed signals to the compressed case leads to low collusion resistance. To
overcome this problem and improve the collusion resistance, a new technique for
fingerprinting compressed signals called Anti-Collusion Dither (ACD) is proposed,
whereby a random dither signal is added to the compressed host before embedding so as
to make the effective host signal appear more continuous. The proposed technique is
shown to reduce the accuracy with which attackers can estimate the host signal, and from
an information theoretic perspective, the proposed ACD technique increases the maximum
number of users that can be supported by the fingerprinting system under a given attack.
Both analytical and experimental studies confirm that the proposed technique increases the
probability of identifying a guilty user and can approximately quadruple the collusion
resistance compared to conventional Gaussian fingerprinting.
 INTRODUCTION

The main idea behind fingerprinting is to embed a fingerprint signal in every legally
distributed copy of the content that uniquely identifies the recipient. When an unauthorized
copy is discovered, the embedded fingerprint can be extracted and used to identify the
source of the leak. Multiple malicious users may collaborate to launch powerful
Collusion attacks against the fingerprinting system. By comparing their different
versions, the colluders can attempt to create a copy that cannot be traced back to any of
them. In this project, we address the problem of designing collusion-resistant fingerprints
for compressed multimedia.
One representative application scenario is an online music/video store that
wishes to deter illicit redistribution of the content purchased from the store.
Primarily based on proprietary security protocols and data formats, most existing
digital rights management (DRM) techniques are not interoperable between devices
from different vendors and often restrict the freedom of the users to play the content on
the device of their choice .Further, if the protection provided by the DRM technique is
circumvented, the user can redistribute the content without fear of being apprehended.
Embedding imperceptible fingerprints, on the other hand, does not restrict content to be
packaged in any proprietary format. Thus, it is interoperable and can be incorporated into
existing systems to complement other protection techniques. For an online store to
deploy fingerprinting to protect its multimedia content, the fingerprints should be
embedded in the source audio or video files that are typically stored in compressed form
to conserve storage space. When a user purchases a particular content, a unique
fingerprint is embedded in the host audio or video signal and this fingerprinted signal is then
transmitted to the user over the Internet in compressed form to conserve bandwidth. As it
is possible for users to gather multiple fingerprinted versions of the same content and
apply collusion attacks, the embedded fingerprints should be resilient to collusions. This
scenario highlights the necessity of collusion-resistant fingerprint design for compressed
multimedia.
A digital TV service provider delivers compressed video to millions of subscribers.
The video is compressed to meet bandwidth requirements and may be further encrypted to
prevent unauthorized users from viewing the content. At the viewer’s end, a set-top box
decrypts, decompresses, and then displays the video stream. A malicious user who can
then rebroadcast or resell the content for profit may intercept the video output of the set-
top box. Digital fingerprinting can be employed to deter and trace these adversaries. If
the fingerprint embedding is performed at the source (TV service provider), a unique
stream would have to be transmitted to each user. The amount of bandwidth required for this
scheme would

be several orders of magnitude higher than broadcasting a single stream to all users. The
bandwidth consumption can be reduced by employing coding techniques to reduce the
number of different versions of the content that need to be transmitted but would still be
several times the amount of bandwidth required to transmit just one stream. An attractive
alternative is to embed the fingerprints at the set-top box, which has already been secured
and tamper-proofed for performing decryption. This post-distribution fingerprinting
approach requires only a single transmission of the host video to all users. In this case, the
set-top box would have to embed a fingerprint in the host stream that has been previously
compressed. In order to combat adversaries who may store the video output of the set-top
box and then collude to remove traces of their fingerprints before redistributing the
content, the fingerprints embedded should be robust against collusion attacks.
DESIGN
 TECHNOLOGY

Overview of the .NET Framework

The .NET Framework is a new computing platform that simplifies application

development in the highly distributed environment of the Internet. The .NET
Framework is designed to fulfill the following objectives:

• To provide a consistent object-oriented programming environment whether object

code is stored and executed locally, executed locally but Internet-distributed, or
executed remotely.
• To provide a code-execution environment that minimizes software deployment
and versioning conflicts.
• To provide a code-execution environment that guarantees safe execution of code,
including code created by an unknown or semi-trusted third party.
• To provide a code-execution environment that eliminates the performance
problems of scripted or interpreted environments.
• To make the developer experience consistent across widely varying types of
applications, such as Windows-based applications and Web-based applications.
• To build all communication on industry standards to ensure that code based on the
.NET Framework can integrate with any other code.

The .NET Framework has two main components: the common language runtime and
the .NET Framework class library. The common language runtime is the foundation of
the .NET Framework. You can think of the runtime as an agent that manages code at
execution time, providing core services such as memory management, thread
management, and remoting, while also enforcing strict type safety and other forms of
code accuracy that ensure security and robustness. In fact, the concept of code
management is a fundamental principle of the runtime. Code that targets the runtime is
known as managed code, while code that does not target the runtime is known as
unmanaged code. The class library, the other main component of the .NET Framework, is
a comprehensive, object-oriented collection of reusable types that you can use to develop
applications ranging from traditional command-line or graphical user interface (GUI)
applications to applications based on the latest innovations provided by ASP.NET, such
as Web Forms and XML Web services.

Features of the Common Language Runtime

The common language runtime manages memory, thread execution, code execution, code
safety verification, compilation, and other system services. These features are intrinsic to
the managed code that runs on the common language runtime.

With regards to security, managed components are awarded varying degrees of trust,
depending on a number of factors that include their origin (such as the Internet, enterprise
network, or local computer). This means that a managed component might or might not
be able to perform file-access operations, registry-access operations, or other sensitive
functions, even if it is being used in the same active application.

The runtime enforces code access security. For example, users can trust that an
executable embedded in a Web page can play an animation on screen or sing a song, but
cannot access their personal data, file system, or network. The security features of the
runtime thus enable legitimate Internet-deployed software to be exceptionally feature
rich.

The runtime also enforces code robustness by implementing a strict type- and code-
verification infrastructure called the common type system (CTS). The CTS ensures that
all managed code is self-describing. The various Microsoft and third-party language
compilers generate managed code that conforms to the CTS. This means that managed
code can consume other managed types and instances, while strictly enforcing type
fidelity and type safety.

In addition, the managed environment of the runtime eliminates many common software
issues. For example, the runtime automatically handles object layout and manages
references to objects, releasing them when they are no longer being used. This automatic
memory management resolves the two most common application errors, memory leaks
and invalid memory references.

The runtime also accelerates developer productivity. For example, programmers can
write applications in their development language of choice, yet take full advantage of the
runtime, the class library, and components written in other languages by other
developers. Any compiler vendor who chooses to target the runtime can do so. Language
compilers that target the .NET Framework make the features of the .NET Framework
available to existing code written in that language, greatly easing the migration process
for existing applications.

While the runtime is designed for the software of the future, it also supports software of
today and yesterday. Interoperability between managed and unmanaged code enables
developers to continue to use necessary COM components and DLLs.

The runtime is designed to enhance performance. Although the common language

runtime provides many standard runtime services, managed code is never interpreted. A
feature called just-in-time (JIT) compiling enables all managed code to run in the native
machine language of the system on which it is executing. Meanwhile, the memory
manager removes the possibilities of fragmented memory and increases memory locality-
of-reference to further increase performance.

Finally, the runtime can be hosted by high-performance, server-side applications, such as

Microsoft® SQL Server™ and Internet Information Services (IIS). This infrastructure
enables you to use managed code to write your business logic, while still enjoying the
superior performance of the industry's best enterprise servers that support runtime
hosting.

Server Application Development

Server-side applications in the managed world are implemented through runtime hosts.
Unmanaged applications host the common language runtime, which allows your custom
managed code to control the behavior of the server. This model provides you with all the
features of the common language runtime and class library while gaining the performance
and scalability of the host server.

The following illustration shows a basic network schema with managed code running in
different server environments. Servers such as IIS and SQL Server can perform standard
operations while your application logic executes through the managed code.

Server-side managed code

ASP.NET is the hosting environment that enables developers to use the .NET Framework
to target Web-based applications. However, ASP.NET is more than just a runtime host; it
is a complete architecture for developing Web sites and Internet-distributed objects using
managed code. Both Web Forms and XML Web services use IIS and ASP.NET as the
publishing mechanism for applications, and both have a collection of supporting classes
in the .NET Framework.

XML Web services, an important evolution in Web-based technology, are distributed,

server-side application components similar to common Web sites. However, unlike Web-
based applications, XML Web services components have no UI and are not targeted for
browsers such as Internet Explorer and Netscape Navigator. Instead, XML Web services
consist of reusable software components designed to be consumed by other applications,
such as traditional client applications, Web-based applications, or even other XML Web
services. As a result, XML Web services technology is rapidly moving application
development and deployment into the highly distributed environment of the Internet.

If you have used earlier versions of ASP technology, you will immediately notice the
improvements that ASP.NET and Web Forms offers. For example, you can develop Web
Forms pages in any language that supports the .NET Framework. In addition, your code
no longer needs to share the same file with your HTTP text (although it can continue to
do so if you prefer). Web Forms pages execute in native machine language because, like
any other managed application, they take full advantage of the runtime. In contrast,
unmanaged ASP pages are always scripted and interpreted. ASP.NET pages are faster,
more functional, and easier to develop than unmanaged ASP pages because they interact
with the runtime like any managed application.

The .NET Framework also provides a collection of classes and tools to aid in
development and consumption of XML Web services applications. XML Web services
are built on standards such as SOAP (a remote procedure-call protocol), XML (an
extensible data format), and WSDL (the Web Services Description Language). The .NET
Framework is built on these standards to promote interoperability with non-Microsoft
solutions.

For example, the Web Services Description Language tool included with the .NET
Framework SDK can query an XML Web service published on the Web, parse its WSDL
description, and produce C# or Visual Basic source code that your application can use to
become a client of the XML Web service. The source code can create classes derived
from classes in the class library that handle all the underlying communication using
SOAP and XML parsing. Although you can use the class library to consume XML Web
services directly, the Web Services Description Language tool and the other tools
contained in the SDK facilitate your development efforts with the .NET Framework.

If you develop and publish your own XML Web service, the .NET Framework provides a
set of classes that conform to all the underlying communication standards, such as SOAP,
WSDL, and XML. Using those classes enables you to focus on the logic of your service,
without concerning yourself with the communications infrastructure required by
distributed software development.

Finally, like Web Forms pages in the managed environment, your XML Web service will
run with the speed of native machine language using the scalable communication of IIS.
 SAMPLE CODE

HOME PAGE

using System;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;
using System.Data.SqlClient;

public partial class _Default : System.Web.UI.Page

{
String cnstr = "server=.;database=gen;trusted_connection=yes;";
SqlConnection cn;
protected void Page_Load(object sender, EventArgs e)
{
cn = new SqlConnection(cnstr);
cn.Open();
string str1 = "select * from tag";
SqlDataAdapter dap = new SqlDataAdapter(str1, cn);
DataSet ds = new DataSet();
dap.Fill(ds, "tag");
foreach(DataRow dr in ds.Tables[0].Rows)
{
 drd1.Items.Add(dr[0].ToString());
}
}
protected void drd1_SelectedIndexChanged(object sender, EventArgs e)
{

}
protected void btn1_Click(object sender, EventArgs e)
{
cn = new SqlConnection(cnstr);
cn.Open();
string str = "Select * from reader;";
SqlCommand cmd = new SqlCommand(str, cn);
SqlDataReader dr1 = cmd.ExecuteReader();
if (dr1.Read())
{
Session["user"] = txt1.Text;
Session["tag"] = drd1.SelectedItem.ToString();
Response.Redirect("welcome.aspx");
}
else
{
System.Windows.Forms.MessageBox.Show("invalid reader");
}
}

protected void Button2_Click(object sender, EventArgs e)

{
Response.Redirect("reg.aspx");
}
}

WELCOME PAGE

using System;
using System.Collections;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;
using System.Data.SqlClient;

public partial class welcome : System.Web.UI.Page

{
string cnstr = "server=.;database=gen;trusted_connection=yes;";
SqlConnection cn;
string s,k,s1;
protected void Page_Load(object sender, EventArgs e)
{
lbl5.Text =Session["user"].ToString();
cn = new SqlConnection(cnstr);
cn.Open();
string str = "select * from reader where rname = '"+ lbl5.Text+ "'";
SqlCommand cmd = new SqlCommand(str,cn);
SqlDataReader dr = cmd.ExecuteReader();
if(dr.Read())
{
s = dr.GetString(0);
}
if (lbl5.Text == s)
{
dr.Close();
string key = "select rkey from reader where rname ='" + lbl5.Text + "'";
SqlCommand cmd1 = new SqlCommand(key, cn);
SqlDataReader dr1 = cmd1.ExecuteReader();
if (dr1.Read())
{
string k = dr1.GetString(0);
TextBox1.Text = k;
lbl3.Visible = true;
btn1.Visible = true;
}
//s1 = s.Substring(0, 16);
}
else
{
lbl4.Visible = true;
}
/*{
s1 = s.Substring(3, 16);
}
TextBox1.Text = s1;
cmd.Dispose();
cn.Close();
cn = new SqlConnection(cnstr);
cn.Open();
 string str1 = "Select rkey from reader where rname = '" + Session["user"].ToString()
+ "'";
SqlCommand cmd1 = new SqlCommand(str1, cn);
SqlDataReader dr1 = cmd1.ExecuteReader();
if (dr1.Read())
{
k = dr1.GetString(0);
if (s1.Equals(k))
{
TextBox2.Text = k;
lbl3.Visible = true;
btn1.Visible = true;
}
else
{
}
}
else
{
lbl4.Visible = true;
}*/
}
protected void btn1_Click(object sender, EventArgs e)
{
Response.Redirect("epcdata.aspx");
}
protected void Button1_Click(object sender, EventArgs e)
{
Session.Abandon();
Response.Redirect("Default.aspx");
}}
TAG PAGE
using System;
using System.Collections;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;
using System.Data.SqlClient;

public partial class tag : System.Web.UI.Page

{
string cnstr = "server=.;database=gen;trusted_Connection=yes;";
SqlConnection cn;
protected void Page_Load(object sender, EventArgs e)
{
lbl2.Text = Session["tag"].ToString();
cn = new SqlConnection(cnstr);
cn.Open();
string str = "select * from tag where tagid = '" + Session["tag"].ToString()+"'";
SqlCommand cmd = new SqlCommand(str, cn);
SqlDataReader dr = cmd.ExecuteReader();
if (dr.Read())
{
lbl3.Visible = true;
}
 else
{
lbl4.Visible = true;
}
}
protected void Button1_Click(object sender, EventArgs e)
{
Session.Abandon();
Response.Redirect("Default.aspx");
}
}
 SCREENSHOTS

TESTING

CONCLUSION
In this project, we developed a framework to analyze collusion attacks on fingerprinting
systems for compressed multimedia and proposed an ACD technique to improve the
collusion resistance. The proposed fingerprinting technique reduces the accuracy with
which adversaries can estimate the host signal and remove the fingerprints. We also analyze
the fingerprinting rate of the system and show that the proposed technique has a higher
asymptotic rate under a given attack. Simulation results demonstrate that with the proposed
ACD technique, the collusion resistance of the fingerprints can be approximately quadrupled
under the averaging and median attacks as compared to fingerprinting using quantized
Gaussian fingerprints without ACD.Similar results have been obtained for the minimum,
maximum, min-max, and randomized min–max collusion attacks. We also note that some
types of collusion strategies, such as modified negative, give slightly smaller probability
of detection under ACD due to larger overall distortion introduced by the collusion and
reduced statistical symmetry in detection after ACD.The simulation results are consistent
with the analytical results obtained.
REFERENCES

[1] Y. Yacobi, “Improved Boneh-Shaw fingerprinting,” in Proc. Topics Cryptology – CT-

RSA, San Francisco, CA, Apr. 2001, vol. 2020, Lecture Notes in Computer Science, pp.
378–391.

[2] “The Cost of Movie Piracy” The Motion Picture Association of America, 2006
[Online]. Available: http://www.mpaa.org/press_re- leases/leksummarympa.pdf

[3] M. Wu, W. Trappe, Z. J. Wang, and K. J. R. Liu, “Collusion resistant fingerprinting for
multimedia,” IEEE Signal Process. Mag., vol. 21, no.2, pp. 15–27, Mar. 2004.

[4] Q. Liu, R. Safavi-Naini, and N. P. Sheppard, “Digital rights management for content
distribution,” in Proc. Australasian Information Security Workshop, Adelaide, Australia,
2003, vol. 21, pp. 49–58.

[5] R. H. Koenen, J. Lacy, M. Mackay, and S. Mitchell, “The long march to interoperable
digital rights management,” Proc. IEEE, vol. 92, no.6, pp. 883–897, Jun. 2004.

[6] S. He and M. Wu, “Collusion-resistant video fingerprinting for large user group,”
IEEE Trans. Inf. Forensics Security, vol. 2, no. 4, pp.697–709, Dec. 2007.

[7] S. He and M. Wu, “Joint coding and embedding techniques for multi-media
fingerprinting,” IEEE Trans. Inf. Forensics Security, vol. 1, no. 2, pp. 231–247, Jun. 2006.

[8] H. V. Zhao and K. J. R. Liu, “Fingerprint multicast for secure video streaming,” IEEE
Trans. Image Process., vol. 15, no. 1, pp. 12–29, Jan. 2006.

[9] D. Boneh and J. Shaw, “Collusion-secure fingerprinting for digital data,” IEEE
Trans. Inf. Theory, vol. 44, no. 5, pp. 1897–1905, Sep. 1998
.