United States Patent [191
`Grundy
`
`US005291598A
`Patent Number:
`Date of Patent:
`
`[11]
`[45]
`
`5,291,598
`Mar. 1, 1994
`
`[54] METHOD AND SYSTEM FOR
`DECENTRALIZED MANUFACTURE OF
`COPY-CONTROLLED SOFTWARE
`[76] Inventor: Gregory Grundy, 1/21 Hewitt Street,
`Wilston 4051, Queensland, Australia
`[2]] Appl. No.: 864,836
`[22] Filed:
`Apr. 7, 1992
`
`'
`
`[51] Int. Cl.5 ....................... .. G06F 9/00; G06F 12/14
`[52] US. Cl. ........................... .. 395/650; 364/DIG. l;
`364/2864; 364/2865; 364/2866
`[58] Field of Search ................... .. 395/650; 364/2864,
`364/2865, 286.6
`
`[56]
`
`References Cited
`U.S. PATENT DOCUMENTS
`
`4,652,990 3/1987 Pailen et a1. ...................... .. 364/200
`4,685,055 8/1987 Thomas .... ..
`5,034,980 7/1991 Kubota ..... ..
`5,113,518 5/1992 Durst et al. ....................... .. 395/550
`Primary Examiner-Gareth D. Shaw
`Assistant Examiner—A. Katbab
`Attorney, Agent, or Firm—Kenyon & Kenyon
`[57]
`ABSTRACT
`A system to control the use of an informational product
`
`is disclosed. The informational product is stored on a
`storage medium and executed by a ?rst processor. The
`informational product is operatable in a plurality of
`modes. The system comprises three manufacture mod
`ules. The ?rst manufacture module, executed by the
`. ?rst processor, generates a registration code for a user
`of the informational product, the registration code
`being a function of the identity of the ?rst processor, the
`, identity of the user and the identity of the informational
`product. The second manufacture module, executed by
`the ?rst processor, accepts as input an authorization
`code, veri?es the authorization code and, if the veri?ca
`tion is successful, changes the operational mode of the
`informational product. The second manufacture mod
`ule also stores a user record in the informational prod
`uct. The third manufacture module examines the user
`record each time the informational product is activated.
`The third module determines the operational mode of
`the informational product as a function of the opera
`tional mode stored in the user record and the identity of
`the processor on which the third module is executed.
`The third module returns to the informational product
`the user record.
`
`43 Claims, 11 Drawing Sheets
`
`lNlTlAL
`
`SEEDING
`PROCESS
`
`Z
`9
`30 DJ
`
`FULL FUNCTION
`COPIES
`
`Petitioners Ex. 1004 Page 1
`
`

`
`US. Patent
`
`Mar. 1, 1994
`
`Sheet 1 of 11
`
`5,291,598
`
`13
`
`~
`MEMORY
`
`A
`v
`
`USER'S ~
`CPU
`
`INPUT/ ‘
`OUTPUT
`DEWCE
`
`CENTRAL ‘\1 12
`DATABASE
`
`0
`19
`~*\15
`f [2 [
`MODEM
`MODEM
`
`A V
`
`CPU
`
`A
`V
`
`INPUT/
`OUTPUT ~—\1e
`DEVICE
`
`FIG. 1
`
`Petitioners Ex. 1004 Page 2
`
`

`
`US. Patent
`
`Mar. 1, 1994
`
`Sheet 2 of 11
`
`5,291,598
`
`INITIAL
`PRODUCT
`DEVELOPMENT
`
`101
`
`DEVELOPER__\
`‘ MODULES
`103
`
`Q,
`00 0
`0
`5*
`Q
`to
`
`.
`
`OBJECT
`CODE
`102b
`
`PRIMING
`PROCESS
`
`102
`
`s “I,
`$5» >9
`
`104
`
`FIG. 1A
`PROCESS OVERVIEW
`
`EVALUATION COPY 106a
`
`COPIES -
`
`o
`
`Q
`
`106
`
`111
`
`,2“
`
`‘ UTHOFIIZATION
`PROCESS
`
`'
`
`FULL FUNCTION
`COPIES
`
`Petitioners Ex. 1004 Page 3
`
`

`
`US. Patent
`
`Mar. 1, 1994
`
`Sl-1eet a of 11
`
`5,291,598
`
`226
`
`%I§IITIL€1Y
`DETAILS
`2:7
`
`6
`
`230
`CORRECT
`TREE
`
`210
`Q “SE
`WORKING
`COPY
`G MESSAGE
`211
`N
`0 Q
`FIE-ENTER
`2 2
`Y
`228
`DETAILS
`ENTER NEW
`ENTER
`USER DETAILS MESSAGE
`AUTHQRIZATION
`GENERATE . ‘T- :)
`REG'STRATION
`SAVE NEw
`CODE
`00 214
`OWNER
`DETAILS
`
`213
`DIEIZEAY
`a
`EXOZRANBE
`REGESOSET'ON Y
`206
`GSETN'EKET
`207
`O8 ‘ REGISTRATION & 2
`Y
`AUTHORIZATION
`EXIT OPTION m
`CODES
`1
`217 -
`ENTER
`AUTHORIZATION
`CODE
`
`INITIALIZE
`
`201mm
`ENABLE
`MES AGE
`
`SAVE LICENSE 204
`
`’
`
`205
`
`\
`DISPLAY
`BANNER
`PAGE
`
`N
`209 I
`Y
`agTtIjg?R Q
`
`o ?
`
`N
`
`229
`
`|
`
`SAVE OWNER
`SHIP DETAILS \SOO
`
`CHANGE
`LICENSE
`
`219
`cORREcT
`PROBLEM
`MESSAGE
`
`223
`cORREcT
`PROBLEM
`MESSAGE
`
`F|G_ 2
`
`N 225
`
`Y
`
`PROOESS
`EVALUATION
`MODE OPTIONS
`
`220
`RECORD
`Q CODE FOR
`FUTURE
`MESSAGE
`Egg!)
`CODE AND
`INSERT
`BACKUP
`DISK
`
`22
`
`PROcESS
`FULL FUNCTION
`MODE OPTIONS
`
`224
`
`Petitioners Ex. 1004 Page 4
`
`

`
`U-S. Patent
`
`-
`
`Mar. 1, 1994
`
`Sheet 4 Of 11
`
`301
`
`_
`
`317
`
`ENTER
`USER DATA
`
`EEEIESIRAIION
`
`CODE
`
`302
`
`ALLOCATE
`NEXT OwNER
`IDENTIFICATION
`NUMBER
`
`318
`
`GENERATE
`
`AUTHORIZATION '
`
`OOOE
`
`‘
`
`.
`
`303
`
`CALCU LAT
`‘CHECKSUM
`3% ESSE‘EE’II
`MESSAGE
`
`HEg??Ms
`
`YES
`
`3°6
`
`305
`
`OORRE T
`PRQBLECM
`MESSAGE
`
`COMMUNICATE
`CODE TO
`NEW OwNER
`
`311
`32¢
`
`T REOORO
`
`?liggIrAiafIg?
`
`IN OATA BASE
`
`322
`
`ID NUMBER
`
`‘RETREIvE PRODUCT
`
`307
`
`I
`
`.‘.
`
`308
`
`309
`
`SPLIT REGISTRATION
`. ,
`
`CALCULATE
`USER DATA
`HE KSUM
`310
`
`
`
`HECKSUMS ATCH
`
`YES 312
`
`312
`
`OPERATOR
`
`PROBLEM
`
`m 314
`
`FIG. 3 AUTHORIZATION
`PROCESS
`
`316
`
`CONFIRM
`REGO DETAILS
`WITH USER
`
`Petitioners Ex. 1004 Page 5
`
`

`
`US. Patent
`
`Mar. 1, 1994
`
`Sheet 5 of 11
`
`5,291,598
`
`LOAD
`OWNERSHIP
`DETAILS
`RECORD
`
`DECRYPT
`OWNERSHIP
`DETAILS
`RECORD
`
`402
`
`GENERATE
`HARDWARE ID
`
`SET
`EVALUATION
`MODE
`
`ENCRYPT
`DETAILS
`RECORD
`
`RETURN ERROR
`STATUS
`
`/404
`v
`RETURN OWNERSHIP
`DETAILS RECORD
`
`FIG. 4
`GET USER DATA MODULE
`
`Petitioners Ex. 1004 Page 6
`
`

`
`US. Patent
`
`Mar. 1, 1994
`
`Sheet 6 of 11
`
`5,291,598
`
`500
`
`501
`
`CHECK VALIDITY
`OF USER DATA
`502
`NO
`
`OK
`(2
`
`YES
`CALCULATE
`USER DATA
`REFER N .
`
`R
`
`CALCULATE
`HARDWARE ID
`
`CALCULATE
`ANTI-VIRUS
`HE K M
`
`ASSEMBLE
`REGISTRATION
`RECORD
`
`PACK REGO
`RECORD INTO
`BIT ARRAY
`
`ENCRYPT
`IT ARRAY
`
`ADD PRODUCT/
`VERSION ID
`T BIT ARRAY
`
`ADD DATA ENTRY
`CHECKSUM
`
`CONVERT BIT
`ARRAY TO
`RE ISTRATIN ODE
`
`505
`
`506
`
`507
`
`508
`
`509
`
`510
`
`51-1
`
`512
`
`513
`
`RETURN
`REGISTRATION
`CODE
`
`514
`
`15
`
`RETURN
`ERROR
`STATUS
`
`FIG. 5
`GENERATE
`REGISTRATION
`CODE
`MODULE
`
`Petitioners Ex. 1004 Page 7
`
`

`
`US. Patent
`
`Mar. 1, 1994
`
`Sheet 7 of 11
`
`5,291,598
`
`GEE! O0
`
`FIX SIMPLE DATA
`ENT
`HY ERRORS
`
`O1
`
`AUTHBRRITQE'IEQDECOE
`INT BIT ARRAY
`
`02
`
`03
`
`604
`
`EIEEARRYRPATY
`
`CALCULATE
`AuTRoRIzATIo
`DE H K M
`05
`
`N o 0
`
`YES
`CALCULATE
`HARDWARE
`IDENTITY
`
`06
`
`607
`
`NO 6
`NO R YES 609
`NO % YES
`R
`
`'10
`
`CALCULATE usER
`DATA CHECKSUM
`611
`NO
`
`GENERATE
`owNERsRIP
`DETAILS REcoRD
`
`14
`
`'
`
`ENcRYPT
`owNERsRIP
`DETAILS REcoRD
`
`sToRE
`
`15
`
`16
`
`RETURN
`OK
`STATUS
`
`SP8
`
`RETURN ’
`UPDATE
`ERRDR
`
`FIG. e
`
`Petitioners Ex. 1004 Page 8
`
`

`
`US. Patent
`
`Mar. 1, 1994
`
`Sheet 8 0f 11
`
`_
`
`5,291,598
`
`ENCRYPT
`OWNERSHIP
`DETAILS RE
`
`RETURN '
`ERROR
`STATUS
`
`FIG. 7
`PRIME BACKUP MODULE
`
`Petitioners Ex. 1004 Page 9
`
`

`
`US. Patent I
`
`Mar. 1, 1994
`
`Sheet9of 11
`
`5,291,598
`
`m 104
`
`- RECORD PRODUCT
`DETAILS
`
`O1
`
`GENERATE
`DONOR IMAGE
`
`808
`
`ASSIGN PRODUCT 802
`IDENTITY #‘S
`& VERSION
`
`OVERWRITE
`DEVELOPER
`MODULES
`
`GENERATE
`PRODUCT
`ENCRYPTI O N C DE
`
`803
`
`CALCULATE
`ANTI-VIRUS
`CHECKSUM
`
`809
`
`810
`
`‘ LOCATE DEVELOPE
`MODULES
`ADDRESS
`
`804
`
`UPDATE
`CENTRAL
`DATABASE
`
`GENERATE
`OWNERSHIP
`DETAILS RECRD
`
`805
`
`ENCRYPT
`OWNERSHIP
`DETAIL RECRD
`
`806
`
`GENERATE
`MANUFACTURE
`MD LE
`
`807
`
`FIG. 8
`FRANKING PROCESS
`
`Petitioners Ex. 1004 Page 10
`
`

`
`US. Patent
`
`Mar. 1, 1994
`
`Sheet 10 of 11
`
`5,291,598
`
`FIG. 9
`DEVELOPER MODULES
`/
`
`PRIME
`BACKUP
`COPY ENTRY
`
`SAVE
`OWNERSHIP
`DETAILS ENTRY
`
`919
`
`GET
`AUTHORIZATION
`CODE ENTRY
`20
`
`915
`nseocons YES YES
`
`9/01
`GET I
`OWNERSHIP
`DETAILS ENTRY
`02
`READOWNERSHIP
`
`1
`
`FILE
`
`903
`NO
`
`ES
`
`RETURN
`
`OWNERSHIP
`DETAILS
`
`DATA
`CONTAINS
`Z'
`NO
`91
`RETURN FIXED
`AUTHORIZATION
`CODE
`W
`m
`922
`
`Z'
`NO
`
`907
`
`916
`
`917
`RETURN
`5%‘;
`
`CREATE
`904 WQELE'ETIQD
`
`-
`
`.
`
`.
`
`CREATE
`_
`KJU FgNclg
`
`.
`
`m 05 ‘WRITEIEY‘IEIERSHIP
`909
`908 a N O
`910
`YES
`RETURN
`OWNERSHIP
`
`918
`
`Petitioners Ex. 1004 Page 11
`
`

`
`US. Patent
`
`Mar. 1, 1994
`
`Sheet 11 of 11
`
`5,291,598
`
`1001
`
`DEVELOPER TABLE
`DEVELOPER ID
`NAME
`ADDRESS
`PHONE NUMBER
`FAX NUMBER
`
`1003
`
`1004
`
`1005
`
`PRODUCT TABLE
`PRODUCT ID
`PRODUCT NAME
`DEVELOPER ID
`VERSION BEING -
`AUTHORIZED
`
`VERSION TABLE
`
`PRODUCTNERSION ID
`OWNER ID
`PRODUCT ID
`PRODUCT VERSION ID
`VERSION NUMBER
`ANCESTOR OWNER ID
`COST
`DATE
`UPGRADE COST,
`MACHINE ID
`ENCRYPTION KEY
`ANTI-VIRUS CHECKSUM _
`
`I
`LICENSE TABLE
`
`I
`OWNER TABLE
`
`OWNER |D
`NAME
`ADDRESS
`PHONE NUMBER
`
`FIG. 10
`SCHEMATIC OF CENTRAL DATABASE
`
`Petitioners Ex. 1004 Page 12
`
`

`
`1
`
`5,291,598
`
`METHOD ‘AND SYSTEM FOR DECENTRALIZED
`MANUFACTURE OF COPY-CONTROLLED
`SOFTWARE
`
`FIELD OF INVENTION
`The present invention is directed to a computer based
`method and apparatus to control the distribution of
`information, and more particularly, a method and appa
`ratus whereby a user of computer software becomes the
`primary agent of manufacture and distribution of the
`software under the direct monitoring and control of a
`centralized control point.
`
`10
`
`2
`an individual piece of software can be done swiftly and,
`relative to the initial production costs, at minimal cost.
`For example, by using operating system commands, a
`user can simply copy a program from a storage device
`such as a disk using one of the user’s disk drives to
`another storage device. This illegal copying of software
`duplicates, on a small scale, a developer’s manufactur
`ing process. However, the unauthorized copying of
`computer software cannot be controlled by the manu
`facturer and the distribution of authorized copies can
`not be traced.
`The software manufacturing industry is placed in an
`unfortunate position. The purchase price of software is
`‘ relatively high to re?ect the cost of design and coding.
`The consumer is often averse to paying a high price for
`software, especially for software that cannot be evalu
`ated before purchase (because the manufacturer will not
`allow access to the software before the purchase to
`prevent pre-purchase copying), and when the consumer
`is faced with a low risk of being detected and prose
`cuted for copying software, there is a strong incentive
`to make an unauthorized copy of the software. In effect,
`unlicensed, pirated software competes directly for the
`same market as legally manufactured software. The lost
`revenue to the manufacturer is passed on to the con
`sumer via higher purchase prices, further increasing the
`incentive for piracy. With the current trend in the in
`dustry to develop software which has an intuitive,
`graphical interface, not requiring manuals to operate it,
`this problem can only increase as users do not require
`access to dif?cult to copy instruction manuals and tuto
`rials. Further, pirated software can be quickly and
`widely distributed over telephone lines using modems.
`One approach the industry has taken to improve the
`return on investment in the manufacture and distribu
`tion of software is to attempt to decrease the amount of
`software piracy. Software developers have used vary
`ing copy protection schemes. These schemes generally
`prevent a user from copying software or using an unau~
`thorized copy of software. Schemes include "dongles”,
`“code-wheels”, storing the software on dif?cult to copy
`storage devices such as copy protected disks, using
`enabling access codes provided in user manuals or by
`the developer that must be entered before the software
`will work, or using hardware speci?c validation codes
`that allow a piece of software to operate only on one
`identi?ed computer. Alternatively, a software devel
`oper could use a hardware copy‘ protection scheme
`where an access code is supplied by a unique or difficult
`to copy hardware device able to be attached to only one
`computer at a time. Typically, when licensed software
`is not given an access code, the standard practice is for
`the software to refuse to operate. See, for example, US
`Pat. No. 4,562,306 (Method and Apparatus for Protect
`ing Computer Software Using an Active Coded Hard
`ware Device) and 4,748,561 (Method of Protecting
`Computer Software).
`Copy protection schemes have not been effective in
`stemming the tide of piracy, mainly because there are
`many specialized anti-copy products available to “un
`lock” the copy protection. Further, some copy protec
`tion schemes prevent consumers from legitimately mak
`ing backup copies of the software for use when the
`authorized copy fails or is destroyed.
`Another approach to prevent piracy of software is to
`require the authorized user, upon the ?rst start-up of the
`software, to input the user’s name (which is then stored
`
`25
`
`40
`
`45
`
`BACKGROUND OF THE INVENTION
`Traditionally, ‘computer software is manufactured
`and distributed through a system where a developer
`creates software (by designing a solution to a problem
`and coding that solution), manufactures the software in
`mass at a production facility, packages the software and
`then distributes it to the consumer. The software, in the
`form of computer code, is stored on a secondary storage
`device, such as a disk. Software products are generally
`manufactured by copying the computer code to the
`required number of storage devices. In a normal distri
`bution chain, the consumer, who may be a purchaser or
`licensee, generally acquires the software (i.e., a storage
`device containing a copy of the computer code) from
`wholesale or retail dealers who in turn have acquired
`the software from the manufacturer.
`A problem with the traditional system for the manu
`facture and distribution of computer software is that
`each software developer has its own substantial produc
`tion, packaging and transportation costs, plus ?xed
`overhead costs for facilities and personnel. When added
`to the initial investment required to develop software,
`such costs often make the launching of a new product
`prohibitive for the developer, especially where the de
`veloper is an individual or small corporation. Produc
`tion and distribution is costly, and these costs are passed
`on to the consumer by way of higher product prices or
`fees. Additionally, the developer, where demand for a
`product is uncertain, may not know how many copies of
`a piece of software to manufacture and distribute. Pro
`duction of too many or too few copies results in lost
`pro?ts.
`One approach taken by a segment of the software
`industry in order to reduce the inherent costs associated
`with the traditional manufacture and distribution of
`software is to invite consumer participation through the
`50
`concept of “shareware” software. Shareware is soft
`ware available for copying by consumers free of charge
`or at nominal costs from electronic bulletin boards ac
`cessed using modems or through mail order catalogue
`services. If, after having had an opportunity to use the
`software for a short period of time, the user decides to
`keep the software, the user is then under a good faith
`obligation to register the software and return a fee to
`the developer or distributor. In practice, the consumer
`participation in copying and distributing the available
`software is good, but the honorarium is rarely paid. As
`a direct consequence of the poor returns to shareware
`developers in general, the quality of products and level
`of support is low.
`Another and very signi?cant problem facing the
`manufacturer of computer software is the unauthorized
`reproduction of software products. Computer software
`is expensive to design and code, but the duplication of
`
`65
`
`Petitioners Ex. 1004 Page 13
`
`

`
`5,291,598
`3
`in the software’s code) such that the user’s name will
`appear on the initialization screen on each successive
`re-use in order to identify the user to whom the soft
`ware is licensed or sold. This practice is intended to
`discourage authorized software users from allowing
`their software to be reproduced, knowing that they can
`be identi?ed readily from an unauthorized copy of the
`software. However, as the software producer is unlikely
`to know when the software is illegally copied and is
`unlikely to be able to track down unauthorized users,
`such a scheme does not discourage copying. Further,
`there is no identi?cation of users who pirate pirated
`software.
`An approach to reduce piracy prior to purchase but
`to allow a potential consumer to test a piece of software
`is to distribute demonstration software without the full
`functional features of the software program. This per
`mits the user to sample the user interface and certain
`features of the software without having to purchase the
`software product “sight unseen". If the user likes the
`software, the user can contact the developer or distribu
`tor for the fully functional software upon registration
`and payment of a license fee or the purchase price. The
`problem with such demonstration software is that twice
`the number of software products have to be produced
`and distributed. One or more storage mediums contain~
`ing software must be produced and distributed for dem
`onstration and one or more storage mediums containing
`different software must be produced and distributed for
`full function operation. This increases the costs of pro
`duction and distribution. Further, the user is inconve
`nienced by twice having to contact or visit the distribu
`tor and is delayed until the full function software is
`obtained.
`One solution to the problem of having to obtain addi
`tional fully functional software is to initially provide to
`the user the full function program but to have only
`certain ?les active for demonstration purposes. Then, if
`the user wants to enable the full function, the user must
`contact the developer or distributor for registration and
`payment of the license fee or purchase price in return
`for an access code. However, once the access code is
`revealed, unauthorized copies can be made and the
`access code can be passed on with the unauthorized
`copy of the software. Therefore, this is not effective
`protection. Typically the process also requires the over
`head of serializing each individual software copy at a
`central point of manufacture.
`As a result of the high overhead costs of the tradi
`tional means of manufacture and distribution of soft
`ware, and the signi?cant level of unauthorized repro
`duction of software, there is a need in the software
`industry for a system that takes advantage of the soft
`ware consumers’ ability to manufacture and distribute
`copies of software using their own equipment while at
`the same time controlling access to the software so that
`the person who designed and coded the software re
`ceives fees for its use. In other words, there is a need in
`the industry for a method of manufacture and distribu
`tion that invites rather than restricts consumer partici
`pation in the manufacture and distribution process but
`does not reduce the incentive of the original manufac
`turer to create the software.
`Software is not the only product that suffers from
`these problems. Other developers and distributors in the
`information industry, such as developers and distribu
`tors of databases and other informational products, also
`have dif?culties controlling access to their product
`
`40
`
`35
`
`45
`
`55
`
`60
`
`65
`
`4
`where it can be loaded onto a user’s own machine. They
`have a product that individual users ?nd easy to copy
`and distribute, but which is costly for the developer to
`initially design, make and ef?ciently distribute. Devel
`opers and distributors of information products desire to
`harness the user’s ability to copy and distribute their
`product but only where they can obtain a fee for their
`initial involvement.
`As a result, there is a signi?cant and substantial need
`in the information industry to allow developers to sell
`their information product to the full potential market
`ef?ciently, that encourages and takes advantage of con
`sumer participation in the manufacture and distribution
`of the information products yet has centralized monitor
`ing and control, that permits consumers to evaluate the
`product prior to the purchase decision, that effectively
`combats piracy, and that permits developer pro?t for
`funding of support and update services.
`
`15
`
`25
`
`SUMMARY OF THE INVENTION
`The present invention provides a method and appara
`tus that monitors and controls the use of information
`stored on a storage medium. The information, in ma
`chine readable form, can be, for example, a computer
`software program or a database. In the representative
`embodiment, the information is a software product.
`According to the present invention, the software
`products are created by software developers capable of
`being operated in two modes. The ?rst mode is a full
`function mode, where all the functions and features of
`the software product are available to the user of the
`software product. The second mode is an evaluation
`mode, where only certain functions, decided by the
`software developer, can be accessed by the user. The
`evaluation mode allows potential users to try and evalu
`ate features of the software product. Each software
`product is stored on a storage medium, in the represen
`tative embodiment, on disk. On each disk (or set of
`disks) the software product is capable of being operated
`in both modes. However, each software product oper
`ates in only one mode at a time.
`The present invention, in the representative embodi
`ment, involves two computers. A ?rst computer, the
`user’s computer, executes the software product. A sec
`ond computer, belonging to a Central Authority, con
`tains a database that stores information about software
`products recognized by the Central Authority and
`about the users who are authorized to operate software
`products in full-function mode.
`When a new user obtains a disk containing a software
`product, the software product will operate in the evalu
`ation mode. The new user can freely operate the soft
`ware in the evaluation mode and make other copies,
`which will also be in the evaluation mode. If the new
`user wishes to use the software product in full-function
`mode, the new user contacts the Central Authority to
`obtain an authorization code. It is expected that the new
`user will pay a fee for obtaining the’authorization code.
`To obtain the authorization code, the new user will
`conduct, on the user’s computer, a registration process.
`A Get Registration Code Module, a separate executable
`segment of the software product, produces for the new
`user a registration code. The registration code is a code
`made by the Get Registration Code Module based
`upon, inter alia, the version and identity of the software
`product, the identity of the user’s computer, the identity
`of the previous user (if any) and data about the new
`user. (The data about the new user had previously been
`
`Petitioners Ex. 1004 Page 14
`
`

`
`5,291,598
`5
`6
`entered by the user as requested by the software prod
`software product is placed in evaluation mode, copied
`uct.)
`and distributed in the marketplace and to potential us
`The new user transmits the registration code to the
`ers. Details of the software product are stored in the
`Central Authority. At the Central Authority, an autho
`Central Authority’s database. In performing the Frank
`rization process takes place. The registration code is
`ing Process, the Central Authority is not given access to
`decoded by the Central Authority and from the con
`the software product’s source code or object modules,
`preserving con?dentiality.
`tained information, an authorization code is made. The
`new user provides user information to the Central Au
`The Manufacture Modules contain computer instruc
`thority, plus a fee, and obtains the authorization code.
`tions that encrypt the registration code and decrypt the
`The new user then enters the authorization code into
`authorization code which allows the user to operate the
`the user’s computer to become an authorized user and
`software product in full-function mode. Further, com
`the software product will operate in full-function mode.
`puter instructions allow the detection of whether the
`In some cases, for example, when requested by the
`software product has been tampered with. In the Au
`software producer, the authorization code is able to be
`, thorization Process, the Central Authority checks for
`used on later versions of the same software product.
`tampering of the software product to prevent the prolif
`Thus, the authorization process and conversion to full
`eration of copies of software products that have been
`function mode takes place at the user’s own site. Details
`corrupted or tampered with.
`of authorized users and from whom authorized users
`Many software developers can create software prod
`obtain the software product are stored in the Central
`ucts that contain developer modules and that are capa‘
`Authority’s database.
`ble of being used in two modes. The Central Authority’s
`After the user enters the authorization code, a Save
`database is capable of storing information about various
`Ownership Details Module modi?es the executable
`software products and various authorized users.
`code of the software product. The modi?cation ensures
`that the software product will operate free of evaluation
`mode limitations on the user‘s computer upon which the
`registration process took place.
`Further, a Prime Backup Module ensures that every
`authorized user holds a backup copy of the software
`product. The backup copy is in the evaluation mode,
`and so can be freely be copied for distribution to other
`potential users, who can register themselves as autho
`rized users as described above. However, the backup
`copy is such that if the registered user’s software prod
`uct fails, the backup copy (or a copy of the backup
`copy) can, using the previously obtained authorization
`code, be converted to full-function mode.
`Each time a user starts the software product, a Get
`User Data Module checks what mode the software
`product is operating in. It does this by examining an
`ownership details record stored by the Save Ownership
`Details Module. If in evaluation mode, the user can
`access only designated features of the software product,
`as discussed above. If in full-function mode, the Get
`User Data Module will check to see if the software
`product is being used on the user’s computer upon
`which the registration process took place. If it is not, the
`software product will automatically revert to evalua
`tion mode. When in full-function mode, the authorized
`user’s name is displayed on the screen.
`The four modules above, namely the Get User Data
`Module, the Generate Registration Code Module, the
`Save Ownership Details Module and the Prime Backup
`Module are what are referred to as Manufacture Mod
`ules.
`When the software product is created, the software
`developer inserts four "dummy” developer modules
`into the code of the software product. This is called the
`priming process. The developer modules simulate the
`operation and interfaces of the Manufacture Modules
`for testing and development purposes. The developer
`modules are made freely available by the Central Au
`thority.
`As the next step in the creation of the software prod
`uct, the software product containing the developer
`modules is transferred to the Central Authority. The
`65
`Central Authority performs a Franking Process on the
`software product whereby the four developer modules
`are replaced with the four Manufacturers Modules. The
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`FIG. 1 is a block diagram of an exemplary computer
`system incorporating the information distribution sys
`tem of the present invention.
`FIG. 1A is a data ?ow diagram illustrating the over
`all process of the present invention.
`FIG. 2 is a flow chart diagram of the operation of the
`Manufacture Modules of the present invention and their
`interaction with the host software product.
`FIG. 3 is a flow chart diagram of the Authorization
`process of FIG. 1A.
`FIG. 4 is a ?ow chart diagram of the Get User Data
`Module of FIG. 2.
`FIG. Sis a ?ow chart diagram of the Generate Regis
`tration Code Module of FIG. 2.
`FIG. 6 is a flow chart diagram of the Save Ownership
`Details Module of FIG. 2.
`FIG. 7 is a flow chart diagram of the Prime Backup
`Module of FIG. 2.
`FIG. 8 is a flow chart diagram of the Franldng pro
`cess of FIG. 1A.
`FIG. 9 is a ?ow chart diagram of the Developer
`Modules of FIG. 1A.
`FIG. 10 is an example table structure of the Central
`Database of FIG. 1A.
`
`55
`
`DETAILED DESCRIPTION
`Referring now to the drawings, and initially FIG. 1,
`there is illustrated in block diagram form an exemplary
`computer system incorporating the information distri
`bution system of the present invention.
`A user’s computer processor 10 is coupled to a mem
`ory device 11 and an input/output device 12. A second
`ary storage device 13 contains a copy of an informa
`tional product 14. In the representative embodiment,
`the informational product 14 is a software product, such
`as a computer program, and the secondary storage de
`vice 13 is a disk. The computer program stored on the
`secondary storage device 13 is loaded onto the memory
`device 11, or is coupled to the memory device 11 and
`accessed by the user's computer processor 10. The com
`puter program is executed by the user’s computer pro
`cessor 10.
`A Manufacture Control Agency operates a second
`computer processor 15, coupled to a Central Database
`
`20
`
`25
`
`30
`
`35
`
`40
`
`45
`
`Petitioners Ex. 1004 Page 15
`
`

`
`5,291,598
`7
`8
`112. An operator (not shown) at the Manufacture Con
`scription of the Developer Modules 102b is provided
`trol Agency accesses the Central Database by means of
`below and shown in FIG. 9.
`a second input/output device 16 coupled to the second
`The resultant software product 1040, after complet
`computer processor 15. An Authorization Process 109,
`ing the priming process 102, is then tested thoroughly
`as illustrated below in FIG. 1A, is conducted using the
`before a copy is sent to the central Manufacture Control
`second computer processor 15.
`Agency where the Franking process 104 is conducted.
`The user and the Manufacture Control Agency com
`Franking is a process whereby the Manufacture Con
`municate with each other. In a representative embodi
`trol Agency modifies the primed host software product
`ment, the communication takes place via a telephone
`provided by the developer 1040 by overwriting the
`line 20. The user’s computer processor 10 is coupled to
`Developer Modules therein with a set of four speci?
`a modem 18 which is coupled to the telephone line 20.
`cally created Manufacture Modules to create an evalua
`A second modem 19 is coupled to the second computer
`tion mode copy of the host software product. A more
`processor 15 which is also coupled to the telephone line
`detailed description of the Franking process is provided
`20. A registration code (109a FIG. 1A), as determined
`, below and shown in FIG. 8.
`by the informational product 14 operating on the user’s
`The Manufacture Modules created during the Frank
`computer processor 10, is communicated to the second
`ing Process 104 comprise the software instructions nec
`computer processor 15 which in response returns an
`essary to control the steps of getting data about a new
`Authorization Code (10817 FIG. 1A). The Authoriza
`user of the host software product and determining the
`tion Code is used to enable the informational product 14
`operational mode of the software each time it is used,
`to operate in a fully functional manner, as described
`generating the registration code needed by new users
`below.
`when arranging to convert their copy of the host soft
`Referring now to FIG. 1A, there is illustrated a data
`ware product to full-function mode, performing the
`flow diagram showing the various processes of the
`conversion to full-function mode, and allowing the user
`present invention. The data flow of the present inven
`to make a primed backup copy of the host software
`tion is shown in the context of software manufacture
`product. The Franking Process 104 generates Manufac
`and the distribution. However, the present invention is
`ture Modules that are customized to each host software
`not limited to the manufacture and distribution of soft
`product. The Manufacture Modules contain features
`ware. Other informational products, such as databases,
`which provide security against tampering with or cor
`could be the product that is developed and distributed.
`ruption of the code of the host software product.
`The diagram shows each' component process of the
`Part of the Franking process 104 also involves the
`present invention and the inputs and outputs of each
`storage of information 1120 about the software product
`process. Each process is shown as an oval labelled and
`in the Central Database 112 operated by the Manufac~
`numbered. The inputs to and outputs from the processes
`ture Control Agency. The Central Database 112 can
`are shown as directional lines labelled with a number
`contain information about numerous host sof