(12) United States Patent
`Pearce et al.
`
`I lllll llllllll Ill lllll lllll lllll lllll lllll 111111111111111111111111111111111
`US006243468Bl
`US 6,243,468 Bl
`Jun.5,2001
`
`(10) Patent No.:
`(45) Date of Patent:
`
`(54) SOFTWARE ANTI-PIRACY SYSTEM THAT
`ADAPTS TO HARDWARE UPGRADES
`
`(75)
`
`Inventors: David B. Pearce, Woodinville, WA
`(US); Aidan Hughes, Houston, TX
`(US)
`
`(73) Assignee: Microsoft Corporation, Redmond, WA
`(US)
`
`( *) Notice:
`
`Subject to any disclaimer, the term of this
`patent is extended or adjusted under 35
`U.S.C. 154(b) by 0 days.
`
`(21) Appl. No.: 09/070,518
`
`(22) Filed:
`
`Apr. 29, 1998
`
`(51)
`
`Int. Cl.7 ....................................................... H04K 1/00
`
`(52) U.S. Cl. ............................ 380/255; 380/258; 380/44;
`380/266
`
`(58) Field of Search ........................ 705/26, 57; 713/187,
`713/190, 200, 201; 455/410; 380/250, 27,
`258; 707/9-10, 203; 709/229; 711/100
`
`(56)
`
`References Cited
`
`U.S. PATENT DOCUMENTS
`5,199,066 * 3/1993 Logan .
`5,357,573 * 10/1994 Walters .................................. 705/56
`5,379,343 * 1/1995 Grube et al. ......................... 455/410
`5,491,804 * 2/1996 Heath et al.
`............................. 710/7
`5,502,831 * 11/1998 Grube et al. ......................... 711/100
`5,509,070 * 4/1996 Schull .................................... 705/54
`5,666,411 * 9/1997 McCarty ................................ 705/51
`5,754,864 * 5/1998 Hill ........................................ 705/26
`5,757,907 * 5/1998 Cooper et al. .
`5,761,649 * 6/1998 Hill ........................................ 705/27
`5,835,911 * 11/1998 Nakagawa ............................ 707/203
`6,041,411 * 3/2000 Wyatt.
`
`FOREIGN PATENT DOCUMENTS
`0 844 549 Al * 5/1998 (EP) ................................. G06F/1/00
`* cited by examiner
`Primary Examiner-V. Millin
`Assistant Examiner--Cuong H. Nguyen
`(74) Attorney, Agent, or Firm-Lee & Hayes, PLLC
`ABSTRACT
`
`(57)
`
`An anti-piracy system reduces the opportunity for piracy and
`illicit use of software products by requiring each software
`product to be registered for a single computer. If a user
`attempts to install the software product on another computer,
`the software product will recognize a different hardware
`composition and disable itself. During installation, the soft(cid:173)
`ware product generates a hardware ID that identifies the set
`of hardware components and sends it and a product ID to a
`registration authority. The registration authority computes a
`registration ID from the product ID and the hardware ID and
`sends the registration ID back to the software product. Each
`time the software product is subsequently launched, the
`software product computes its own test ID from the product
`ID and hardware ID using the same algorithm employed by
`the registration authority. The software product then com(cid:173)
`pares the test ID to the registration ID. If the two match, the
`software product is enabled; otherwise, if no match occurs,
`the software product is locked. The system flexibly accom(cid:173)
`modates a situation in which the user upgrades one or a few
`components in the computer without creating a new
`machine. The software product determines whether a new
`set of hardware components in the computer is substantially
`different from the original set of hardware components. If
`not substantially different, the upgraded computer is more
`like the original computer and the software product is
`permitted to operate; otherwise, the computer more
`resembles a new computer and the software product is
`prevented from operating.
`
`39 Claims, 6 Drawing Sheets
`
`22~1
`
`24
`
`CD Key
`
`i Install
`
`Customer Computer
`
`c
`
`Processor
`
`System Memory
`
`'
`
`6~
`~hing'
`rithm
`[__!'r()dUct ID ~~-
`Reg ID
`- - - - - -----------
`
`32
`
`40
`
`PIO+ HIWID
`
`42
`
`-100
`112
`
`102
`
`-118
`
`,r-30
`
`110
`
`112
`
`e~
`
`Reg. ID
`
`34
`
`Registration Server
`'
`·teegistratio~Unit I
`°',
`Algorithm J .
`'
`_
`Hashing
`
`,
`
`Registration
`Database
`
`114
`
`116
`
`Customer
`
`Registration Authority
`
`APPLE EXHIBIT 1014
`Page 1 of 15
`
`

`

`U.S. Patent
`
`Jun.5,2001
`
`Sheet 1 of 6
`
`US 6,243,468 Bl
`
`22
`
`20
`
`•
`
`Generate and
`Assign Serialized
`CD Key
`
`22
`
`24
`
`CD Key
`
`APPLE EXHIBIT 1014
`Page 2 of 15
`
`

`

`lo-"
`~
`~
`O'I
`~
`~
`'N
`O'I
`rJ'J.
`
`e
`
`O'I
`0 .....,
`N
`~
`
`'Jl =(cid:173)~
`
`'"""'
`N c c
`~ = ?
`
`Ul
`
`~
`
`~ = ......
`~ ......
`~
`•
`\JJ.
`d •
`
`I Reg ID
`
`PIO I H1W ID
`
`116
`
`Database
`Registration
`
`114
`
`Reg. ID
`
`~·
`
`Algorithm
`Hashing
`
`Registration Unit
`
`Registration Server
`
`34
`
`112
`
`110
`
`~··36
`
`r3o
`
`Registration Authority
`
`7'9-2
`
`Customer
`
`-:t-f-102
`
`112
`100
`
`42
`
`1 I
`
`PIO+ H/WID
`
`I
`
`I Reg ID
`
`[ Product ID I
`
`Al orithm
`Hashing
`Program
`
`System Memory
`
`i
`:
`:
`
`I
`I
`
`'·--------------·!T 118
`
`n 40
`
`Processor
`
`Customer Computer
`
`32
`
`nstall
`
` I
`-l
`
`--
`
`24 J (CD Key 1
`
`22
`
`APPLE EXHIBIT 1014
`Page 3 of 15
`
`

`

`lo-"
`~
`~
`O'I
`~
`~
`'N
`O'I
`rJ'J.
`
`e
`
`O'I
`0 .....,
`~
`
`~ .....
`'Jl =(cid:173)~
`
`'"""'
`N c c
`~ = ?
`
`~Ul
`
`~ = ......
`~ ......
`~
`•
`\JJ.
`d •
`
`Modem
`
`90
`
`36
`
`76
`
`56
`
`D
`
`80
`
`Interface
`Network
`
`Interface
`Serial Port
`
`Drive
`Optical
`
`~66
`Interface
`
`\_ 66
`
`64
`
`Data
`
`Program
`
`62
`Modules
`
`Other
`
`60
`Programs
`Application
`
`System
`Operating
`
`~ ------·-·-·-·----·---·------------·-----------------
`
`Interface
`Disk Drive
`Magnetic
`
`Interface
`
`Drive
`
`Hard Disk
`
`74
`Program Data
`
`Modules 72
`Other Program
`
`'?itf,3
`
`---~
`
`System Bus
`
`44
`
`: I c__ __ __,
`
`Programs 70
`\
`Application
`
`(
`
`System 68
`Operating
`
`84
`
`VBIOS
`
`Video Adapter
`
`-_I
`
`48
`
`-
`
`-
`
`-
`
`-
`
`-
`
`-
`
`-
`
`-
`
`-
`
`-
`
`-
`
`-
`
`--·--
`
`-
`
`-
`
`-
`
`-
`
`-
`
`-
`
`-
`
`-
`
`-
`
`-·--
`
`(RAM)
`
`~~:D
`
`Processing Unit
`
`82
`
`32
`
`40
`
`BIOS §Q) :
`-(Raf.A) ___ -------------45--f
`System Memory
`:
`---------·------------------
`
`[
`
`42
`
`APPLE EXHIBIT 1014
`Page 4 of 15
`
`

`

`U.S. Patent
`
`Jun.5,2001
`
`Sheet 4 of 6
`
`US 6,243,468 Bl
`
`Software Product on
`Customer Computer
`
`Reaistration Unit on
`Product Provider Server
`
`Get PIO
`
`Generate
`Hardware ID
`(H/W ID)
`
`150
`
`152
`
`Send PIO and H/W ID
`to Registration
`Authority
`
`154
`
`Store Reg ID
`
`162
`
`Compute
`Registration ID
`(Reg ID)
`
`Store PIO, H/W
`ID, and Reg ID
`
`Send Reg ID to
`Customer
`Computer
`
`156
`
`158
`
`160
`
`APPLE EXHIBIT 1014
`Page 5 of 15
`
`

`

`U.S. Patent
`
`Jun.5,2001
`
`Sheet 5 of 6
`
`US 6,243,468 Bl
`
`Start Program
`
`Get PIO
`
`Generate H/W ID
`
`Compute test ID from
`PIO and H/W ID
`
`Retrieve Reg ID from
`Memory
`
`Compare test ID with
`Reg ID
`
`170
`
`172
`
`174
`
`176
`
`178
`
`180
`
`No
`
`182
`
`Yes
`
`Lock Program
`
`186
`
`184
`Allow Program to
`Operate
`
`APPLE EXHIBIT 1014
`Page 6 of 15
`
`

`

`U.S. Patent
`
`Jun.5,2001
`
`Sheet 6 of 6
`
`US 6,243,468 Bl
`
`Change Bit in H/W ID to
`. - - - - - - - - - . i
`get Modified H/W ID
`
`Concatenate PIO and
`Modified H/W ID
`
`Compute test ID from
`PIO and Modified
`H/WID
`
`Compare test ID with
`Reg ID
`
`190
`
`192
`
`194
`
`196
`
`204
`
`Yes
`
`Lock Program
`
`Allow Program to
`Operate
`
`200
`
`APPLE EXHIBIT 1014
`Page 7 of 15
`
`

`

`US 6,243,468 Bl
`
`1
`SOFTWARE ANTI-PIRACY SYSTEM THAT
`ADAPTS TO HARDWARE UPGRADES
`
`TECHNICAL FIELD
`
`This invention relates to systems and methods for pre(cid:173)
`venting piracy or illicit use of software. More particularly,
`this invention relates to such systems and methods that allow
`hardware components of the underlying computer to be
`upgraded and the software to be legitimately installed on the
`upgraded machine without triggering the anti-piracy protec(cid:173)
`tion.
`
`BACKGROUND
`
`10
`
`2
`a CD-ROM or floppy diskette. The disk 20 is packaged to
`form a shrink-wrap retail product 22. The manufacturer
`generates and assigns a serialized key that uniquely identi(cid:173)
`fies that product. For instance, the key might consist of a
`5 manufacturer ID, a serialized incrementing number, a reg(cid:173)
`istered product code, and a checksum value. The key is
`printed on a label 24 and affixed somewhere on the product,
`such as the CD-ROM case.
`During installation, the purchaser of the software product
`is prompted to enter the key. This step alone is designed to
`prevent another party from obtaining the disk 20 only,
`without knowledge of the key, and installing the product
`illegally. Without the key, the holder of the physical disk is
`prevented from installing the product.
`The product tracks the number of installations. Once the
`purchaser enters the same key more times than a defined
`limit, the product is disabled. The purchaser is then forced
`to call the manufacturer for assistance.
`While such mechanisms help reduce illicit copying, they
`20 often cause other problems in the form of consumer incon(cid:173)
`venience. For instance, the premise that more installations
`than a requisite number means illegal use may be wrong in
`some cases. A user who has upgraded his/her computer, for
`example, should be able to legitimately reinstall the software
`25 product on the upgraded machine. However, if the requisite
`number of installations has already been reached, the prod(cid:173)
`uct will not install, forcing the user (who is now disgruntled)
`to call the manufacturer for assistance.
`Accordingly, there remains a need for improved technol-
`ogy solutions to piracy and illicit use, but which also
`recognizes and accommodates the needs and practices of a
`legitimate purchaser.
`
`30
`
`Computer software is a unique consumer product in that 15
`the same product can be replicated many times after being
`sold. Once a software product is sold, typically as software
`code on a computer-readable disk, the purchaser can easily
`copy the code to other computer-readable media thereby
`replicating the same product many times over.
`This characteristic of software can be a tremendous
`benefit in terms of lowering manufacturing costs and facili(cid:173)
`tating distribution. For instance, easy replication allows a
`software manufacturer to distribute one physical copy of the
`software product and sell a multi-seat license that legally
`empowers the purchaser to install the software product on
`many different computers.
`Unfortunately, this benefit comes at a cost of open abuse.
`One well-known abuse is piracy. An unscrupulous party can
`obtain a copy of the object code (legally or illegally) and
`then illicitly replicate and resell pirated copies of the prod(cid:173)
`uct. Software companies attempt to monitor piracy
`activities, but detection is often difficult. Moreover, even
`when improper activity is detected, enforcement and legal
`recourse is often unavailable from a practical standpoint, 35
`particularly since much of the abuse occurs in foreign lands.
`A less subtle abuse is the improper use of the software
`product beyond the scope of the license. One common
`scenario involves a shrink-wrap software product available
`at local retail stores. The product is typically accompanied
`by a shrink-wrap license to install and use the product on one
`computer, and perhaps additionally on a laptop.
`Unfortunately, the purchaser may intentionally or uninten(cid:173)
`tionally install the product on more than the allowed
`computers, thereby violating the license. For the software
`manufacturer, this form of abuse is very difficult to monitor
`and even more difficult to prosecute.
`The computer software industry estimates that billions of
`dollars are lost each year due to piracy and other illicit uses. 50
`While licenses provide a legal avenue for recourse against
`such practices, the practicality of detecting and enforcing
`often prove too onerous for the manufacturer. Accordingly,
`software companies have a real incentive to reduce the
`amount of abuses through other means.
`One conventional technique for preventing unlimited
`copying of a software product is to design the code with a
`self-regulating mechanism that prevents repeated installa(cid:173)
`tions. This mechanism counts the number of installations
`and disables the software code after the product has been 60
`installed a certain number of times. The underlying premise
`is that multiple installations tend to indicate that the user is
`attempting to install the product on multiple different
`computers, rather than just one computer allowed by the
`license.
`FIG. 1 illustrates this concept. A manufacturer creates a
`software product and places the code on a disk 20, such as
`
`40
`
`45
`
`SUMMARY
`This invention concerns an anti-piracy system and method
`that reduces the opportunity for piracy and illicit use of
`software products by requiring each software product to be
`registered for a single computer that consists of a specific
`hardware composition. If a user attempts to install the
`software product on another computer, the software product
`will recognize a different hardware composition and disable
`itself
`According to one aspect of the invention, the system
`includes a software product that is loaded onto a specific
`computer having a set of hardware components (e.g., RAM,
`hard disk drive, floppy disk drive, BIOS, network card,
`video card, etc.). The software product has an associated
`product ID consisting of, for example, a manufacturer ID, a
`registered product code, a serialized number, and a check(cid:173)
`sum value.
`During installation, the software product generates a
`hardware ID that identifies the set of hardware components.
`As an example, the software product generates a five-digit
`55 hardware ID that includes a bit representing each of five
`system components: BIOS, a video BIOS in the video card,
`RAM, a hard disk drive, and a floppy disk drive. The bit for
`a given system component can be derived in different ways,
`such as performing a modulo operation on all or part of the
`BIOS, or on the hard disk drive's serial number.
`The software product concatenates the product ID and
`hardware ID and sends it to a registration authority, such as
`the product manufacturer or an authorized third party. The
`registration authority has a registration unit that computes a
`65 registration ID from the product ID and the hardware ID.
`One preferred approach is to hash the concatenation of the
`product ID and hardware ID to produce the registration ID.
`
`APPLE EXHIBIT 1014
`Page 8 of 15
`
`

`

`US 6,243,468 Bl
`
`3
`The registration authority stores the registration ID, product
`ID, and hardware ID in a database. The registration authority
`sends the registration ID back to the software product, where
`the registration ID is stored locally on the computer.
`Each time the software product is subsequently launched,
`the software product again obtains the product ID and
`generates the hardware ID for the computer. The software
`product then computes its own test ID from the product ID
`and hardware ID using the same algorithm (e.g., hashing
`algorithm) employed by the registration unit at the registra(cid:173)
`tion authority. The software product compares the test ID to
`the registration ID. If the two match, the software product is
`enabled to operate on the computer; otherwise, if no match
`occurs, the software product is locked and prevented from
`operating on the computer.
`In the typical case, the test and registration IDs will not
`match if the hardware ID is changed. This indicates that the
`underlying hardware has been altered, either through
`upgrade or because the user is attempting to install the
`product on another computer. At the minimum, the self(cid:173)
`locking mechanism prevents the user from installing the
`software product on multiple different computers. However,
`the system is also sensitive to the situation in which the user
`simply upgrades one or a few components in the computer
`without effectively creating a new machine.
`In this situation, the software product determines whether
`a new set of hardware components in the computer is
`substantially different from the original set of hardware
`components. If only one or a few components are different
`(e.g., not more than two out of five components), the
`upgraded computer is more like the original computer and
`the software product is permitted to operate. Conversely, if
`many or all components are different (e.g., more than two
`out of five components), the "upgraded" computer more
`closely resembles a new computer and the software product
`is prevented from operating on this new computer without
`an additional license from the registration authority.
`One way the software product makes this determination is
`by trying different permutations of the hardware ID, chang(cid:173)
`ing at least one bit per try while leaving other bits
`unchanged. Each modified hardware ID is concatenated with
`the product ID, and then hashed to produce the test ID. If as
`a result of this trial-and-error process the test and registra(cid:173)
`tion IDs match, the software product is assured that only a
`few of the components have been altered, and the product is
`permitted to run.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`FIG. 1 is a diagrammatic illustration of a prior art manu(cid:173)
`facturing and packaging process to produce a shrink-wrap
`software product.
`FIG. 2 is a block diagram of an anti-piracy system that
`facilitates registration of a software product for installation
`and use on a particular computer.
`FIG. 3 is a block diagram of an exemplary computer.
`FIG. 4 is a flow diagram showing steps in a method for
`registering the software product for use on the computer.
`FIG. 5 is a flow diagram showing steps in a method for
`running the software product on the computer.
`FIG. 6 is a flow diagram showing steps in a method for
`running the software product after the computer has been
`upgraded.
`
`DETAILED DESCRIPTION
`FIG. 2 shows an anti-piracy system 30 that facilitates
`registration of a software product with a registration author-
`
`5
`
`10
`
`20
`
`4
`ity for installation and use on a particular computer.. The
`system 30 includes a customer computer 32 and a registra(cid:173)
`tion server 34, which resides at the registration authority
`remote from the customer. The customer computer 32 and
`registration server 34 are interconnected by a network 36 to
`provide data communication. In the absence of a customer
`computer's access to a network, the manufacturer o~ trus~ed
`third party may provide proxy access to the reg1strat10n
`server by other means, such as electronic mail, fax machine,
`postal mail, or telephone.
`For discussion purposes, the customer computer is
`described as a personal computer, such as a desktop or
`portable computer. However, as used herein, the term "com(cid:173)
`puter" is intended to mean essentially any type of computing
`15 device or machine that is capable of running a software
`product, including such devices as communication devices
`(e.g., pagers, telephones, electronic books, electronic maga(cid:173)
`zines and newspapers, etc.) and personal and home con(cid:173)
`sumer devices (e.g., handheld computers, Web-enabled
`televisions, home automation systems, multimedia viewing
`systems, etc.). Within the described context, the network 36
`is representative of an Internet or Intranet, or a local or wide
`area network. However, the network 36 may be imple(cid:173)
`mented in many different forms, including both wire-based
`25 networks (e.g., cable, telephone, fiber optic, etc.) and wire(cid:173)
`less networks (e.g., RF, satellite, microwave, etc.).
`FIG. 3 shows the customer computer 32 within an exem(cid:173)
`plary implementation of a personal computer. The computer
`32 includes the processing unit 40, system memory 42, and
`30 a system bus 44 that interconnects various system
`components, including the system memory 42 to the pro(cid:173)
`cessing unit 40. The system bus 44 may be implemented as
`any one of several bus structures and using any of a variety
`of bus architectures, including a memory bus or memory
`35 controller, a peripheral bus, and a local bus. The system
`memory 42 includes read only memory (ROM) 46 and
`random access memory (RAM) 48. A basic input/output
`system 50 (BIOS) is stored in ROM 46.
`The customer computer 32 may have one or more of the
`40 following drives: a hard disk drive 52 for reading from and
`writing to a hard disk or hard disk array; a magnetic disk
`drive 54 for reading from or writing to a removable magnetic
`disk 56; and an optical disk drive 58 for reading from or
`writing to a removable optical disk 60 (e.g., CD ROM or
`45 other optical media). The hard disk drive 52, magnetic disk
`drive 54, and optical disk drive 58 are connected to the
`system bus 44 by a hard disk drive interface 62, a magnetic
`disk drive interface 64, and an optical drive interface 66,
`respectively. The drives and their associated computer-
`50 readable media provide nonvolatile storage of computer
`readable instructions, data structures, program modules and
`other data for the computer 32. It is noted that other types of
`computer readable media may also be used to store data.
`Other such media include magnetic cassettes, flash memory
`55 cards, digital video disks, Bernoulli cartridges, random
`access memories (RAMs), read only memories (ROM), and
`the like.
`A number of program modules may be stored on the hard
`disk, magnetic disk 56, optical disk 60, ROM 46, or RAM
`60 48. These programs include an operating system 68, one or
`more application programs 70, other program modules 72,
`and program data 74. The operating system 68 is preferably
`a Windows brand operating system (e.g., Windows NT,
`Windows 98, Windows CE, etc.), although other types of
`65 operating systems may be used. In this implementation, the
`software product can be implemented as one of the programs
`70.
`
`APPLE EXHIBIT 1014
`Page 9 of 15
`
`

`

`US 6,243,468 Bl
`
`6
`serial number. Table I shows an example construction of a
`5-bit hardware I D, and how the bits are derived from the
`corresponding component.
`
`TABLE 1
`
`Bit Place Hardware Component Method
`
`BIOS
`
`Hard Disk Drive
`
`RAM
`
`Floppy Disk Drive
`
`Video Card
`
`Perform modulus 8 on first 2 K
`chunk of BIOS.
`Perform modulus 8 on 64-bit HOD
`serial number.
`Perform modulus 9 of total bytes of
`RAM.
`Perform modulus 9 on FOO
`configuration return value.
`Perform modulus 9 on Video BIOS.
`
`2
`
`3
`
`4
`
`5
`
`15
`
`5
`An operator may enter commands and information into
`the computer 32 via input devices such as a keyboard 76 and
`a mouse 78. Other input devices (not shown) may include a
`microphone, joystick, game pad, satellite dish, scanner, or
`the like. These and other input devices are connected to the 5
`processing unit 40 through a serial port interface 80 that is
`coupled to the system bus 44, but may alternatively be
`connected by other interfaces, such as a parallel port, game
`port, or a universal serial bus (USE). A monitor 82 or other
`type of display device is also connected to the system bus 44 10
`via an interface, such as a video adapter 84. The video
`adapter 84 has a video BIOS (VBIOS) 86. The computer 32
`has a network interface or adapter 88, a modem 90, or other
`means for establishing communications over the network
`36.
`It is once again noted that the computer shown in FIG. 3
`is just one possible type of computing device that can be
`used to implement aspects of this invention. Other types of
`computers may be used.
`With reference again to FIG. 2, the customer purchases a
`software product for running on the computer 32. In this
`illustration, the software product is in the form of a shrink(cid:173)
`wrap product 22 having a software program stored on a
`transportable computer-readable medium, such as a
`CD-ROM or floppy diskette. In other implementations, the
`software product may be delivered electronically over a
`network. The customer loads the software product onto the
`computer 32 as a program 100 stored in system memory 42.
`During installation, the customer is prompted to enter a
`portion of the product ID of the software product. The
`product ID (PID) in this case is the CD key printed on label
`24 of the shrink-wrap package. The customer enters the
`product ID 102, which is associated with the program 100.
`Additionally, another portion of the product ID is already
`included in the software program 100 and the software
`product combines the two portions, along with other
`information, into a product ID that is unique to the specific
`installation.
`As part of the installation process, the customer registers
`the software product with the registration authority. This
`authority might be, for example, the product manufacturer or
`an authorized third party. The registration process forces the
`customer to register the software product for installation and
`use on a specific computer.
`FIG. 4 shows steps in a method for registering the
`software product 100 for installation and use on the com(cid:173)
`puter 32. The method is described with continuing reference
`to FIG. 2. The steps are performed in software by the
`software product on the customer computer, and by a 50
`registration unit on the registration server. At step 150, the
`software product 100 obtains its product ID 102. As an
`example, the product ID consists of a 5-bit RPC (registered
`product code) value for the software product, a 3-bit site
`value indicating a place of manufacture, and a 7-bit serial- 55
`ized number that is incremented with each product.
`The software product 100 generates a hardware ID (H/W
`ID) that identifies a set of hardware components that make
`up the customer's computer 32 (step 152). The hardware ID
`is a multi-bit value having at least one bit representing each 60
`of the corresponding system components. As an example,
`the software product generates a 5-bit hardware ID that
`includes a single bit for each of five system components:
`BIOS 50, VBIOS 86, RAM 48, hard disk drive 52, and
`floppy disk drive 54. A bit for a given system component can 65
`be derived in different ways, such as performing a modulo
`operation on a chunk of the BI OS, or on the hard disk drive' s
`
`30
`
`It is noted that other hardware components may be used.
`For instance, many computers are equipped with a network
`card with a unique 128-bit address. A bit for the hardware ID
`20 can be derived from this global network card address.
`Moreover, more than, or fewer than five system components
`may be used to derive the hardware ID.
`The software product in this example concatenates the
`15-bit product ID with the 5-bit hardware ID, and sends the
`25 20-bit value over the network 36 to the registration server 34
`(step 154 in FIG. 4). This phase is preferably automated in
`that the software product automatically initiates connection
`with the registration server 34 to register itself with the
`registration authority.
`Alternatively, the software product supports a registration
`pilot with a graphical user interface (UI) dialog window
`asking the customer to call a service representative at the
`registration authority. The UI window lists the product ID
`and the hardware ID, and includes a entry box to enter the
`35 registration ID given by the service representative over the
`phone.
`The registration server 34 has a registration unit 110 to
`assign a registration ID (Reg ID) to the software product on
`the customer's computer. The registration unit 110 computes
`40 the registration ID from the product ID and the hardware ID
`(step 156 in FIG. 4). In the illustrated implementation, the
`registration unit 110 employs a hashing algorithm 112 to
`compute a hash value of the concatenated product ID and
`hardware ID. The registration server 34 also maintains a
`45 database 114 to store the product ID, hardware ID, and
`registration ID (step 158 in FIG. 4). Preferably, these IDs are
`correlated in a table or other data record 116.
`The registration server 34 returns the registration ID over
`the network 36 to the customer computer 32 (step 160 in
`FIG. 4). In the manual case, the service representative tells
`the customer the registration ID over the phone and the
`customer enters the registration ID via the UI window. The
`registration ID 118 is stored locally in the system memory 42
`of the customer computer 32, where it is accessible by the
`software program 100 (step 162 in FIG. 4). The program 100
`is also equipped with the same hashing algorithm 112 as
`found in the registration unit 110 at the registration server
`34.
`FIG. 5 shows steps in a method for running the software
`product 100 on the computer 32. The method is described
`with continuing reference to FIG. 2. The steps are performed
`by software code within the software product on the cus(cid:173)
`tomer computer. At step 170, the software product is started.
`On each launch after installation, the software product
`obtains the product ID 102 (step 172) and generates the
`hardware ID from the set of hardware components within
`the computer (step 174).
`
`APPLE EXHIBIT 1014
`Page 10 of 15
`
`

`

`US 6,243,468 Bl
`
`7
`At step 176, the software product 100 computes its own
`test ID from the product ID and hardware ID using the
`hashing algorithm 112. This is the same hashing algorithm
`as employed by the registration unit 110 when computing
`the original registration ID 118. The software product 100 5
`retrieves the original registration ID 118 from memory 42
`(step 178 in FIG. 5) and compares the test ID to the
`registration ID 118 (step 180 in FIG. 5). If the two match
`(i.e., the "yes" branch from step 182), the software product
`is enabled to operate on the computer (step 184). On the 10
`other hand, if no match occurs (i.e., the "no" branch from
`step 182), the software product is locked and prevented from
`operating on the computer (step 186 in FIG. 5).
`The anti-piracy system is effective at stopping repeated
`installation of the same software product on multiple dif(cid:173)
`ferent machines. In the typical case, the test and registration
`IDs will not match if the hardware ID is different now than
`it was when the customer first registered the software
`product with the registration authority. That is, the only thing
`that has changed in the computation of the test and regis(cid:173)
`tration IDs is the hardware ID. The product ID and the hash
`algorithm are the same for both computations.
`A different hardware ID suggests that the underlying
`hardware components have been altered in some manner.
`For instance, reconfiguring the floppy disk drive or replacing 25
`the hard disk drive might change the hardware ID. Of
`course, an entirely different computer with a different set of
`hardware components might also result in a different hard(cid:173)
`ware ID.
`If an unscrupulous customer attempts to install the prod(cid:173)
`uct on another computer, the software product will deter(cid:173)
`mine that the test and registration IDs do not match and will
`self-lock, thereby preventing its operation on the different
`computer. The customer is then forced to contact the regis-
`tration authority to obtain a new registration ID, and if
`appropriate, pay an additional licensing fee for an additional
`installation.
`Another advantage is that the anti-piracy system is sen(cid:173)
`sitive to the situation in which the customer has upgraded 40
`his/her computer, without effectively creating a new
`machine, and is now attempting to reinstall the software
`product on the upgraded computer. In this situation, the
`software product determines whether a new set of hardware
`components in the computer is substantially different from
`the original set of hardware components. If only one or a few
`components are different, the upgraded computer is more
`like the original computer and the software product is
`permitted to operate. Conversely, if many or all components
`are different, the "upgraded" computer more closely 50
`resembles a new computer and the software product is
`prevented from operating on this new computer.
`One way the software product makes this determination is
`by trying different permutations of the hardware ID, chang(cid:173)
`ing at least one bit per try while leaving other bits
`unchanged. Each modified hardware ID is concatenated with
`the product ID, and then hashed to produce the test ID. If this
`trial-and-error process yields a match between the test and
`original registration IDs, the software product is assured that
`only one or a few components have been altered, and the
`software product is permitted to run.
`FIG. 6 shows steps in a method for running the software
`product 100 on the computer 32 after upgrade. The method
`is described with continuing reference to FIG. 2. The steps
`are performed by software code within the software product
`on the customer computer. At step 190, the software product
`changes at least one bit in the hardware ID, while leaving the
`
`8
`other bits unchanged, to p