`
`www.mchiventg
`415.561.6767
`415340—0391 e-fax
`
`Internet Archive
`300 Funsron Avenue
`
`San Francisco, CA 94118
`
`AFFIDAVIT OF CHRISTOPHER BUTLER
`
`1. I am the Office Manager at the Internet Archive, located in San Francisco,
`California. I make this declaration of my own personal knowledge.
`2. The Internet Archive is a website that provides access to a digital library of
`Internet sites and other cultural artifacts in digital form. Like a paper library, we provide
`free access to researchers, historians, scholars, and the general public. The Internet
`Archive has partnered with and receives support from various institutions, including the
`Library of Congress.
`3. The Internet Archive has created a service known as the Wayback Machine. The
`Wayback Machine makes it possible to surf more than 450 billion pages stored in the
`Internet Archive's web archive. Visitors to the Wayback Machine can search archives
`by URL (i.e., a website address). If archived records for a URL are available, the visitor
`will be presented with a list of available dates. The visitor may select one of those
`dates, and then begin surfing on an archived version of the Web. The links on the
`archived files, when served by the Wayback Machine, point to other archived files
`(whether HTML pages or images). If a visitor clicks on a link on an archived page, the
`Wayback Machine will serve the archived file with the closest available date to the page
`upon which the link appeared and was clicked.
`4. The archived data made viewable and browseable by the Wayback Machine is
`compiled using software programs known as crawlers, which surf the Web and
`automatically store copies of web files, preserving these files as they exist at the point of
`time of capture.
`5. The Internet Archive assigns a URL on its site to the archived files in the format
`http://web.archive.org/web/[Year in yyyy] [Month in mm] [Day in dd][Time code in
`hh:mm:ss]/[Archived URL]. Thus, the Internet Archive URL
`http://web.archive.org/web/l9970126045828/http://www.archive.org/ would be the
`URL for the record of the Internet Archive home page HTML file
`(http://www.archive.org/) archived on January 26, 1997 at 4:58 am. and 28 seconds
`(1997/01/26 at 04:58:28). A web browser may be set such that a printout firom it will
`display the URL of a web page in the printout’s footer. The date assigned by the Internet
`Archive applies to the HTML file but not to image files linked therein. Thus images that
`appear on a page may not have been archived on the same date as the HTML file.
`Likewise, if a website is designed with "frames," the date assigned by the Internet
`Archive applies to the frameset as a whole, and not the individual pages within each
`frame.
`
`6. Attached hereto as Exhibit A are true and accurate copies of printouts of the
`Internet Archive's records of the HTML files or PDF files for the URLs and the dates
`specified in the footer of the printout (HTML) or attached coversheet (PDF).
`7. I declare under penalty of perjury that the foregoing is true and correct.
`
`DATE: (7’/i3Z/‘3
`
`1
`
`I
`
`C_.____
`
`Christopher Butler
`
`PayPal Ex. 1054, p. 1
`PayPal v. IOENGINE
`
`

`

`CALIFORNIA JURAT
`
`See Attached Document.
`
`State of California
`
`County of San Francisco
`
`
`
`.
`LAUREL KARB
`Notary Public - Caiiiorma
`San Francisco County22
`
`Commission # 21722 2020
`
`
`My Comm. Expires Nov 17.
`
`
`E
`3
`
`
`
`
`
`A notary public or other officer completing this
`certificate verifies only the identity of the
`individual who signed the document to which this
`certificate is attached, and not the truthfulness,
`
`accuracy, or validity of that document.
`
`Subscribed and sworn to (or affirmed) before me on
`this
`
`lg
`
`dayof bflcgmbgfifi
`
`, 2g]? ,by
`
`Christopher Butler,
`
`proved to me on the basis of satisfactory evidence to be
`the person who appeared before me.
`
`Signatur
`
`1M
`
`PayPal Ex. 1054, p. 2
`PayPal v. IOENGINE
`
`

`

`Exhibit A
`
`PayPal Ex. 1054, p. 3
`PayPal v. IOENGINE
`
`

`

`December 1997
`
`Smart cards: A primer - JavaWorld - December 1997
`
`J‘vgwgmm m It's free!
`luminous I Téfiffiirws;
`.mvn‘n—Esoumrtfl
`
`
`{ranch
`
` Q
`
`Smart cards: A primer
`
`Develop on the Java platform of the future
`
`Summary
`This article. the first in a new Java Developer series on smart cards, will introduce you to smart card bows and whys. All you need is a smart card, a
`card reader, and software that lets you communicate with the card, and you can begin developing a real-world application. This article includes: a
`package to manipulate smart cards using ISO 7816; a demonstration of how to read and write data to a memory smart card using the Gemplus reader
`and a Gemplus smart card; and a discussion of some of the applications that make use of smart card memory features. Future articles will use cards by
`different manufacturers. We'll also touch on smart card standards.
`
`With this first article in the series, we will lay the groundwork for future articles with a discussion of the new and emerging standard called OpenCard.
`Future articles will deal with security cards and electronic purse cards. Finally, this article will teach you some of the basics about smart card software
`architectures. (3,500 words)
`
`
`
`Smart cards have been getting a lot of buzz lately on the Web, at the JavaOne conference last April (four sessions dealt with the technology), on the
`big network news stations, and on CNN. In this article we'll bring the smart card to life with a real-world smart-card example. The techniques
`
`presented herewill allow youtostartbuildingJavaapplications thataresmart-cardenabled.
`
`a
`
`.
`ll .
`We'll focus on two types of smart cards: memory smart cards, which can be viewed as minuscule removable read/write disks with optional security;
`and processor cards, which can be viewed as miniature computers with an input and output port. Future articles will cover processor cards in greater m
`am
`
`As the meat of the article, we'll develop a simple prototype for reading and writing data to a smart card. We will discuss a drug prescription card,
`which keeps a list of all your prescriptions and tracks your insurance, prescription plans, and other useful info. Later articles will expand on the idea of the
`prescription card.
`
`You'll notice that a recurrent theme that runs throughout this series on smart cards is the need for a security framework to prevent rogue plug-ins, ActiveX
`components, and so on from getting at your personal and/or corporate info-goodies. To this end, the demonstration of how to read and write data to a smart card
`included in this article will provide you with persistent, secure (and portable) storage.
`
`What is a smart card?
`You can think of the smart card as a "credit car " with a "brain" on it, the brain being a small embedded computer chip. This card-computer can be programmed to
`perform tasks and store information, but note that the brain is little -- meaning that the smart card's power falls far short of your desktop computer.
`
`Smart cards currently are used in telephone, transportation, banking, and healthcare transactions, and soon -- thanks to developers like you -- we'll begin to see them
`used in Internet applications. Smart cards are already being used extensively in Japan and Europe and are gaining popularity in the US. In fact, three significant
`events have occurred recently in the smart card industry in this country:
`
`Microsoft and several other companies introduced PC/SC, a smart card application interface for communicating with smart wrds from Win32-based platforms for
`personal computers. PC/SC does not currently support non-\Vm32-based systems and may never do so. We will discuss this in greater detail later on.
`
`OpenCard Framework
`OpenCard is an open standard that provides inter-operability of smart card applications across NCs, POS, desktops, laptops, set tops, and so on. OpenCard promises
`to provide 100% pure Java smart card applications. Smart card applications often are not pure because they communicate with an external device and/or use
`libraries on the client. (As a side note, 100% pure applications could exist without OpenCard, but without it, developers would be using home-grown interfaces to
`smart cards.) OpenCard also provides developers with an interface to PC/SC for use of existing devices on Win32 platfroms.
`
`JavaCard was introduced by Schlumberger and submitted as a standard by JavaSoft recently. Schlumberger has the only Java card on the market currently, and the
`company is the first JavaCard licensee. A smart card with the potential to set the overall smart card standard, JavaCard is comprised of standard classes and APIs
`that let Java applets run directly on a standard ISO 7816 compliant card. JavaCards enable secure and chip-independent execution of different applications.
`
`Although this article focuses on smart cards, it is important to note that you are not limited to these kinds of devices. Personally, I prefer the "Ibuttons“
`device being produced by Dallas Semiconductor. It is small and portable like a credit card, but so much handier. Why? You don't have to dig out your
`wallet in search of a card; lbuttons is right there, on your finger. Yes, it‘s a ring!
`
`While contactless versions of the smart card do exist (see below for more information on this),I think the lbuttons, functional-jewelry type of device
`could be quite profitable. For more information on lbuttons, see the Km section. By the way, the Java Commerce Team demonstrated a
`
`PayPal Ex. 1054, p. 4
`PayPal v. IOENGINE
`
`

`

`is more reliable than a magnetic stripe card
`currently can store a hundred times more information than a magnetic stripe card
`is more difficult to tamper with than mag stripes
`can be disposable or reusable
`can perform multiple functions in a wide range of industries
`is compatible with portable electronic devices such as phones, personal digital assistants (PDAs), and PCs
`is constantly evolving (after all, it incorporates a computer chip)
`
`Types of smart cards
`As mentioned above, this article will focus on two types of smart cards -- memory and process. In all. there are five types of smart cards:
`
`1. memory cards
`2. processor cards
`3. electronic purse cards
`4. security cards
`5. JavaCard
`
`Smart cards are a personal piece of hardware that must communicate with some other device to gain access to a display device or a network. Cards can be plugged
`into a reader, commonly referred to as a card terminal, or they can operate using RF radio frequencies.
`
`Smart cards can communicate with a reader or receiver (see the section on readers below for more on these two terms) in one of two forms:
`
`Contact srmrt cards -- The connection is made when the reader contacts a small gold chip on the front of the card.
`
`Contactless smart cards -- These can communicate via an antenna, eliminating the need to insert and remove the card by hand. mm a contactless card, all you have
`to do is get close to a receiver, and the card will begin communicating with it. Contactless cards can be used in applications in which card insertion/removal may be
`impractical or in which speed is important.
`
`Some manufacturers are making cards that function in both contact and contactless modes.
`
`Create a development environment for building smart card apps
`In order to develop smart card applications, you need a few things, namely: a smart card reader; software to communicate with the reader as well as some software
`to communicate with the card that has been plugged into the reader; and, of course, smart cards and smart-card hardware.
`Smart card reader
`To communicate with a smart card or develop an application that is smart-card capable, you must have a reader. The reader provides a path for your application to
`send and receive commands from the card. There are many types of readers on the market, the most prevalent being the serial, PCCard, and keyboard models.
`(Keyboard models pop up here and there; expect them to be directly available from the large PC makers by June 1998.)
`
`This article uses serial readers to support the devices. A serial reader connects to a computer's serial port. Note that the code provided also supports a PCCard
`reader; most laptops come with PCCard slots built in.
`
`Each manufacturer provides a different protocol for speaking to a reader. Once you can communicate with the reader. there is one protocol for communicating with
`a smart card: Communication with a smart card is based on the APDU format. (The APDU format is discussed below.) For information on purchasing your own
`reader, see the "Gemplus smart card readers" heading in the Km section.
`
`Software for communicating with the reader
`A number of object-oriented classes are needed for the smart card example included in this article. These are:
`
`0 ISO command classes for communicating with 7816 protocol
`0 Classes for communicating with the reader
`0 Classes for converting data to a manufacturer-specific format
`. An application for testing and using the cards for the purpose for which the application was designed
`Smart cards and smart card hardware
`As noted at the beginning of the article, in order to develop the smart card application here, you need smart card hardware and some smart cards. You can purchase
`smart card development kits from a number of companies, including Gemplus and Schlumberger.
`
`For those of you who already have readers, you should be able to use your reader by supplying an implementation of an interface class that we will discuss later. As
`mentioned above, before we can communicate with the card, we must be able to communicate with the reader, andjust as there are many different cards, there are
`many difi'erent readers.
`
`Important smart card standards
`An important piece of the smart card application development puzzle is the standard protocols. Basically, the application communicates with the reader, which in
`turn talks to the smart card using a standards protocol -- in our case, the International Standards Organization (ISO) 7816 protocol.
`
`As with any new technology, there are so many standards for smart cards that you may find yourself discouraged and overwhelmed. Achieving a basic
`understanding of the following standards will enable you to develop applications with the confidence that you are not ignoring something basic to using smart cards.
`For some systems, however, special standards come into play. I have broken the whole standards thing down into "horizontal" and "vertical" standards: Horizontal
`standards can be used by all applications, while vertical standards are specific to a system.
`Horizontal standards
`
`ISO 7816 -- describes the lowest-level interface to a smart card. It is at this level that data bytes are transferred between card reader and card.
`0
`httpszllweb archive.orglweb/19980123 l84230!http://www.javaworld.com280/javaworld/jw-12-1997/jw- l2-javadev.htrnl
`
`PayPal Ex. 1054,
`PayPal v. IOENGINE
`
`PayPal Ex. 1054, p. 5
`PayPal v. IOENGINE
`
`

`

`Smart cards: A primer - JavaWorld - December 1997
`0 PC/SC —- the standard for communicating with smart cards connected to Win3.l/Vlfin95lNT machines.
`
`- OCF -- an ail-Java interface for communicating with smart cards from a Java environment. (Soon OCF will allow developers to write to OCF and perform
`the translation, so there'll be no need to write to PC/SC.)
`
`. JavaCard -- describes the JavaCard and what it supports.
`Vertical standards
`
`0 Mondex -- digital cash that uses smart cards only. The Mondex approach does not allow cash to exist outside of the card.
`
`- WsaCash -- debit card that keeps track of the cards on the server.
`I Proton -- another form of E-cash.
`
`0 MPCOS-EMV -- general-purpose card that lets you implement your own type of currency or token.
`
`I am always amazed that such a small piece of plastic could require so much documentation reading and demand so much knowledge on the part of the developer!
`
`Because such a high level of expem'se is necessary with smart cards, there is a market for developers to supply Beans-capable products that implement a vertical
`standard using the horizontal standard for the market you're looking to sell to. This means that you could develop beans that use various combinations of the
`horizontal standards, like OpenCard, to implement a specific application using some other industry standard for commerce or any other application.
`
`Communicate with smart cards from a Java applet or application
`You know what you need to connect up all the hardware. Now we need to understand how to use some APIs that will allow us to send commands from an
`application to a reader. (The reader, in turn, communicates with the card, thereby acting as the intermediary before sending the data to the card.) The smart card
`reader wiggles the gold contact points and transfers the data. The card will do something with the data and retum it to the reader, which will then return the data to
`the application. So where are all these bytes as they are moving from your application to the card?
`
`As mentioned above, the application communicates with the reader, which in turn talks to the smart card using the standards discussed above. Basically, as smart
`card technology developed, a smart card standard was proposed by ISO. The standard defined mechanical and electrical characteristics as well as the protocol for
`communicating with the card. Pointers to the relevant 180 documents are listed in the 3mm section. Unfortunately, the ISO group was unable to provide a
`standard for communicating with the reader. So, in order to send a command to a card, first you need to find the command that the card supports, wrap this
`command in an ISO command packet, and then wrap this new command in the wrapper required for the reader in question. The example application provided here
`performs all of this layering for you.
`
`Application Protocol Data Units (APDUs)
`The basic unit of exchange with a smart card is the APDU packet. The command message sent from the application layer, and the response message returned by the
`card to the application layer, are called an Application Protocol Data Units (APDU). Communication with the card and the reader is performed with APDUs. An
`APDU can be considered a data packet that contains a complete instruction or a complete response from a card. To provide this functionality, APDUs have a well-
`defined structure that is defined in a number of ISO documents belonging to the 7816 specification family.
`
`APDUs consist of the following fields:
`
`Command APDU Format
`
`Res - onse APDU Format
`Data
`
`SW2
`
`SW1
`
`The following are some of the classes provided for transporting APDUs and the classes' functions:
`
`I Command -- encapsulate command APDU
`
`I Response — encapsulate response APDU
`
`ISOCardReader -- specify an interface. Each device has to implement this interface
`
`ISOCommand -- construct an ISOCommand and execute the command through the ISOCardReader interface
`
`Communicating with smart cards
`Sun has developed the Java Electronic Commerce Framework (JECF), an extension to the core Java platform that allows developers to easily and rapidly develop
`electronic commerce applications. JECF provides several classes that support communication with smart cards very easily. (See the flew section for
`information on the JECF.)
`
`The card we are working with in this article has one command for reading data and another command for writing data. This card is referred to as a GFM card and is
`produced by GemPlus. You should be able to use other cards as long as they are ISO 7816-compliant and you have the information on what their APDU commands
`are. Of course you will also have to do a little programing. The GFM card has memory organized in blocks of 64 bits or 8 bytes. You must carry out reads and
`writes using modulo 8 arithmetic. In other words. you cannot write 1K directly as one long contiguous write. The Java code we supply here does this for you. Some
`of the newer cards support larger read/write sizes. So, to write the string "0123456789," you would need to issue two commands with proper indexing of the
`address. (Yes, smart cards can be very difficult to program.) As memory cards and processor cards merge, many of these restrictions are disappearing.
`
`In order to read the above string, you would then need to issue the "rea " command.
`
`PayPal Ex. 1054, p. 6
`PayPal v. IOENGINE
`The two commands we are going to use are formatted below in terms of an APDU. In our case, we use the following Java methods to read and write the card. The
`values in the table below demonstrate how to construct an APDU. The structure of the APDU is defined in the GFM programmer‘s manual.
`
`Location of data
`
`Upper
`
`Lower
`
`

`

`for storing data at the specified addresses. The two methods we have been discussing for communication with a GPM896 smart card are:
`Isocommand(0, OxDO, 0, upper,
`lower, 8); // Write 8 bytes to the address
`
`ISOCommand(0, 0x30, 0, upper,
`
`lower, 5); // Read 3 bytes from the address
`
`Communicating with a smart card from a browser
`The existence of these three native interfaces indicates the lack of understanding of major corporations of developers' need to have simple APIs that they can
`remember when they are in a Java environment. If all vendors supported JNl, then at least the interface would remain constant and you would not have to spend
`hours getting the interface bindings to work. It is true that you would still have to write a small amount of "native code," but there is value in having a consistent
`interface. I have tried all three APls above and found JNI to be more consistent than the rest, as well as the easiest to use and implement. The integration with
`HotJava is the best; with HotJava you can sign the classes that talk to a serial port and use them securely with less hassle than with the other two browsers. Sun has
`recently announced a new initiative to help browser companies implement new versions of the JDK/JVM.
`
`The precceding discussion revolved around how to communicate with a hardware device that does not have JDK support. In the next few articles we will stop
`concentrating on the "native interfaces" and use an industry standard API for communicating with smart cards. The standard I am choosing for communication is
`OpenCard with a PCJ'SC bridge. I will write my appliations to OpenCard not PC/SC. Why?
`
`As a developer you have many choices. Although generally this is a good thing, it also can lead to increased cost and non-uniform functionality when the choices
`are APIs that do no span all the platfonns you need. So, for example, you could decide to write your smart card applications using PC/SC. which provides support
`in the Win32 world. This is a bad idea because if yours is a consumer application and it is brought up on WebTV, the screen will flash with the message: "Wait for
`Pentium version of WebTV." Smart cards are used in markets other than W11132 desktops or CE units. So, what should you do? Write to OpenCard and distance
`yourself from the lack of consistent INI bindings in Internet Explorer. In fact, I think it is a wise move to abstract all APls that only function on one platform.
`
`And now, the real-world application!
`It's time now to lay out the scene for a more significant smart card application. In the future, when we pay a visit to the doctor and he or she suggests we take a
`particular medication, we might be players in the following scenario:
`
`- The doctor asks you for your prescription card.
`
`0 The card is inserted into the reader, and the doctor looks at your prescription history. (For those of us with complex medical/medication histories, an expert
`system may be necessary.)
`-
`
`c The doctor notices that another doctor currently has you on a medication that may react with the drug he or she was thinking of prescribing. So the current
`doctor chooses a different drug and enters the new prescription on your prescription smart card. (Ideally, at this point, the card could transmit the order to the
`pharmacy.)
`
`. You take your card to the pharmacy and insen it into the pharmacy's reader.
`
`0 The pharmacist looks at your prescription history and gets the new prescription.
`
`0 Suppose pharmacies have better data on drugs than doctors, and this particular pharmacist thinks the doctor should reconsider the prescribed drug. The
`pharmacist calls the doctor, whose phone number is included on the prescription smart card. After a brief discussion, the two decide on an alternate
`medication and update the card.
`
`0 The pharmacist fills your prescription, takes the provider plan information off the card, and communicates with the plan provider using an encrypted protocol.
`
`a The medical provider verifies that you are actually a plan member, checks that the prescription comes from an authorized doctor, and takes the opportunity to
`update some data on your card.
`
`- The pharmacist asks you for five dollars.
`
`Sounds like a safer system to me than the (primarily) paper-and-pen system in which humans are the link between disparate computer systems. In fact, in Germany,
`medical smart cards are already in use.
`
`The advantages of the prescription smart card
`So what value do smart cards add to traditional prescription plan "cards"? They offer:
`
`0 Access to card data when you change stores, travel, or deal with new agencies.
`
`0 Instant access to medical history and medication history for ambulance or ER personnel.
`
`0 Itemized records showing what you have been taking -- including when, where, and how much.
`
`0 Data upload/download to approved recipients.
`
`In order to provide support for the above process, we need to develop an application that lets us read and write records to the card in a secure manner. The
`application above simply gives the user the ability to enter data onto the card. For example, your doctor can add your prescription to the card.
`
`Developing the application
`In this section you get the code you need to write data to a smart card and read it back. The first action in the program that is trying to read or write data to a
`memory card is to get a reference to a device that supports a smart card. Once we have the device, we need to write or read the desired string. This is achieved by
`calling on the methods supplied in Cardstrings . java. The prototype classes provided facilitate the programming of smart cards. We've also added a Beans-style
`event handler to inform us of smart card events such as the insertion of a card. (Thanks to Dan Guinan, senior developer on the JECF, for this last tip.)
`https:l/web.archive.org/web/19980123 184130/http:/lwww.javaworld com:80/javaworldljw-12-1997/jw-lZ-javadevhtml
`
`PayPal Ex. 1054, p. 7
`PayPal v. IOENGINE
`
`PayPal Ex. 1054, p. 7
`PayPal v. IOENGINE
`
`

`

`Smart cards: A primer - JavaWorld - December 1997
`
`Consider the following code fragment from Rwstring. java:
`import java.commerce.smartcards.t; Packages form JECF to support smart cards
`import java.commeree.gemplus.*;
`import java.commerce.DeviceHanager.*;
`import java.awt.event.*;
`
`* Read and write Gemplus Memory cards. The following cards
`are supported:
`
`public class RWString (
`
`public static void main( String args[]) {
`Writestring ws - new WriteString(args);
`
`lass Writestring implements ActionListener (
`
`Isocardkeader
`int
`String
`
`isoReader = null;
`portNumber;
`deviceName;
`
`public Writestring(string args[]) (
`
`///////l////////////////////////////
`//
`Process the arguments
`/////////l//////////////////////////
`(
`foz(int i = 0; i < args.length;
`i++)
`if ( args[i].equals("-port”) )(
`portNumber = 0;
`{
`} else if ( args[i].eguals("-device") )
`deviceName = new string ( args[++i]
`} else if ( args[i].equals("-help") )
`{
`System.out.print1n(”Usage: string -port # -device COHI or Idevlttya" )7
`System.exit(0);
`
`);
`
`} S
`
`martCardDetector seDetector = new SmartCardDetector(1000);
`scDetector.addActionListener(this);
`scDetector.startDetection():
`
`ublic void actionPerformed(ActionEvent actionEvent) {
`System.out.print1n("Action Performed:
`‘ + actionEvent
`try {
`
`)7
`
`// Open the requested port number
`SmartcardReader so: = new Smartcardneader();
`isoReader =
`scr.getDefau1t();
`isoReader.begincardsession(GemplusserialReader.GFM);
`Cardstrings.writeGFMString("01234567" ,
`isoneader );
`System.out.println(Cardstrings.readGFMString(isoReader )
`isoReader.endCardSession();
`} catch(Exception e)
`{
`System.out.print1n( "Exception " + e);
`e.printStackTrace();
`} finally (
`try (
`
`);
`
`isoReader.endCardSession();
`} catch(Exception eFinally) {
`System.out.println("Could not power Down card perform manual reset");
`
`}
`
`he class Cardstrings provides some utility methods to read and write strings to the card. The strings are stored on the card with a length field of two bytes,
`followed by six empty bytes, followed by the string data.
`
`As a challenge for those of you who actually get some cards and start programming them, you should be able to modify the methods in Cardstrings to read and
`write Java objects. This is a more flexible approach thanjust writing strings. If you write Java objects you can save data without worrying about its format. I wanted
`to start with something simple that everyone could relate to -- namely, storing some string data on a card.
`
`The following application is a complete example for reading and writing data to a GemPlus GFM card using a GCR4OO serial reader. With a little bit of work other
`readers can be supported. Don't bother doing the work for supporting other readers: Next month we'll be providing an example of how to do this with OpenCard,
`which is quickly becoming the standard in this area.
`package java.commeree.Memorycards;
`
`import java.io.IOException;
`import java.commerce.smartcards.*;
`import java.commerce.gemplus.';
`
`public class CardStrings {
`[it
`i write a string, since the card is modulo 8 and we are
`i not using serialized objects -- the first two bytes are the
`' length followed by six spare bytes. Strings longer than 4096 - 43
`* bits will be truncated.
`
`PayPal Ex. 1054, p. 8
`PayPal v. IOENGINE
`
`

`

`wemd = new ISOCommand(0, Ode, o, 0, 8,0);
`wcmd.data.writeshort( length );
`System.out.println(“Write out the Length”);
`winput a wcmd.execute(isoreader, new GemplusReaderFailureHandlerl));
`// Write the string out
`int wholenmount = length/8;
`int remainder = length % 8;
`// Write the String out groups of 8
`(
`l++ )
`for ( int 1 = 1; 1 <= wholenmount;
`System.out.println("Writing 8 bytes at “ + (1‘8));
`upper = (l * B ) >> 8;
`lower = ( 1 * 8
`)
`& Dxff;
`wcmd = new Isocommand(0, oxdo, upper,
`int index = (
`(1-1) * 8 );
`wcmd.data.write5tring(s.substring(index),8);
`System.out.println("Write out bytes at " + index);
`winput = wcmd.exeeute(isoreader,new GemplueReaderFailureHandler());
`/ Write the remainder out
`) >> 8;
`upper = ((wholeAmount+1)
`* H
`) G Oxff;
`lower = ((wholenmount+1)
`* 8
`wcmd = new ISOCommand(0, Oxdo, upper,
`int index = ( wholenmount * 8 );
`wcmd.data.writestring(s.substring(index),remainder);
`winput = wcmd.execute(isoreader,new GemplusReaderrailureflandler());
`) catch ( Exception e )
`(
`System.out.println( ”Exception " + e);
`e.printstackTrace[);
`
`// Save the length
`
`// Groups of 8
`ll Remainder
`
`lower, 8,0);
`
`lower, remainder,0);
`
`}/
`
`(
`
`" + length);
`
`// Groups of 8
`// Remainder
`
`}l
`
`}r
`
`eturn ( sb.toString() )i
`
`}
`
`[*fi
`* Read a string, since the card is modulo 8 and we are
`* not using serialized objects -- the first two bytes are the
`* length followed by six spare bytes. Strings longer than 4096 — 4B
`* bits will be truncated.
`*/
`public static String readGFMString(Isocardneader isoreader )
`Isocommand
`rcmd;
`ISOCardinputStream rinput;
`int upper,lower;
`short length;
`ab - new Stringauffer();
`StringBuffer
`try (
`// Read the control section
`// Read the length
`rand = new I50Command(0, Oxbo, O, 0, 0, 8);
`rinput - remd.execute(isoreader,new GemplusReaderFsilureHandler());
`length = (short)rinput.readshort()7
`System.out.println(”rhe length is:
`// Read the String
`int wholesmount = length/8;
`int remainder = length 8 8;
`// Read the String in groups of 8
`(
`l++ )
`for ( int 1 = 1; 1 <= wholeAmount;
`system.out.println("Reading 8 bytes at " + (1*E));
`upper = (1 * 8
`) >> 8;
`lower - ( l * 8
`) a Oxff;
`lower, 0, 8);
`rcmd = new ISOCommand(O, Oxbo, upper,
`rinput = rcmd.exeeute(isoreader,new GemplusReadeanilureHandleri));
`sb.append ( rinput.readstring(8) );
`System.out.print1n("String to this point:” + sb.tostring());
`l Read the remainder
`upper - (
`(wholenmount+1) * 8 ) >> 8;
`lower 8 (
`(wholenmount+1) * 8
`)
`& Oxff;
`rand = new Isocommand(o, OxbO, upper,
`lower, 0, 8);
`rinput = rcmd.execute(isoreader,new GemplusReaderFailureHandler());
`sb.append ( rinput.readstring(remainder)
`);
`System.out.println("String to this point:" + sb.tostring());
`} catch ( Exception e )
`{
`System.out.println( "Exception " + e);
`e.printstackrrace();
`return ( null
`);
`
`1
`
`Future articles
`
`In future articles we will discuss ways in which our doctor of the future can securely sign the entry he or she has put on your card, so that the card can function as a
`valid prescrip