Software Litigation Consulting (Andrew Schulman) specializes in source code examination, software reverse engineering, pre-filing investigation of software/internet patent infringement, the preparation of claim charts (infringement & invalidity contentions), and research in software prior art. Services include:
- Pre-filing investigation (in-depth infringement-related inspection of software/internet products services)
- Software reverse engineering, including static (e.g. disassembly) and dynamic (e.g. network packet sniffing) methods
- Mobile app software “teardown” for Android and iPhone (iOS)
- Locating software/internet prior art (for anticipation, on-sale, and public-use)
- Infringement & invalidity contentions (claim charts, including both PICs before source code is available, and post-discovery ICs with “pinpoint” source-code citations)
Services in more detail:
- Source code examination (see FAQ; “Source code and e-discovery“; forthcoming book, due 2017: Source Code Examination for Software & Internet Patent Litigation: A Guide for Attorneys and Experts)
- Using reverse engineering to investigate patent infringement and non-infringement (see article “Hiding in Plain Sight: Using Reverse Engineering to Uncover Software Patent Infringement” in Intellectual Property Today, November 2010)
- Preparation of infringement & invalidity charts, correlating claim limitations on the one hand with elements/steps of software on the other (forthcoming book, due 2017: Claim Charts for Patent Litigation)
- Locating and analyzing software prior art (see article “Open to Inspection: Using Reverse Engineering to Uncover Software Prior Art” (Part 1) in New Matter [Calif. State Bar IP Section], Summer 2011); Part 2 (New Matter, Fall 2011)
- Software reverse engineering (text extraction, class dump, code decompilation/disassembly, network packet monitoring, in-depth examination of web sites/services, etc.)
- Comparison/correlation of source code with products/services (e.g. “latent code” issues; creating source-code maps from binary/object code, as preparation for discovery)
- Open-source examination: comparison/correlation of open source with products/services, and with proprietary source code
- Patent portfolio analysis (e.g. ranking for valuation; initial identification from patent citations of candidate licensees or potential infringers)
- Code comparisons using binary/object code (see “Finding Binary Clones with Opstrings & Function Digests” [parts 1, 2, and 3] in Dr. Dobb’s Journal, 2005)
- Assistance with technical aspects of complaints, summary judgment motions and responses, interrogatory and discovery requests and responses, depositions, expert testimony and cross-exam
- Comparison and correlation of internal documents from discovery (emails, etc.) with resulting technical practices (see e.g. “The Caldera v. Microsoft Dossier,” O’Reilly Media, Feb. 2000).
- See list of sample projects.
Source code examination:
Source code conforms to rules dictated by programming languages, platforms (such as Android, Windows, or the Apple iOS and OSX operating systems), APIs (application programming interfaces), and other constraints (e.g. interoperability with other software and with devices). Source code examination needs to carefully use this structured format, as opposed to merely performing a keyword search, in part because there is typically too much code to read all of it, and much depends on the proper selection of areas requiring close reading. Whereas a simple keyword search might end up treating source code as a disconnected collection of code fragments, a true source-code examination will rely, for example, on:
- the relationship between caller and callee functions;
- child/parent class relationships;
- aliasing of names used for functions, parameters, variables, and data structures;
- actual operation of code (in contrast to relying entirely on the accuracy of names or comments in the code);
- awareness of implicit function calls (e.g. constructor/destructor), implied function parameters, and other implicit code invocations
- classes and modules; directory and filename path information; version control information; and other metadata
- careful attention to function pointers, vtables, operator/function overloading, hooks, on-event handlers/subscribers, run-time dynamic linking, and externally-generated events; and
- tracing data flow.
Also in contrast to a simple keyword search, a source-code examination will be alert to the possibility of code which is unused in the finished product; determining code usage or non-usage may require careful tracing (distinct from searching) through the source code, comparison of the source code with the binary/object code in the finished product, or even dynamic testing of the “live” product.
The dependence of source code on external constraints means that the code can often be correlated with external information, such as API documentation, SDK (software development kit) sample code, header files, open source, and so on.
Other aspects of source-code examination services provided by Software Litigation Consulting include:
- Use of custom-built code-examination tools, as well as industry-standard tools
- Testing completeness of source-code production
- Ability to work with source code written in in-house/proprietary programming languages
- Careful attention to protective order (PO) requirements, including printing limitations
- Comparison of open source with vendor’s proprietary modifications
- In patent cases, searching and code reading in terms of claim construction (including alternative pre-Markman constructions), means-plus-function, and doctrine of equivalents (analysis of code for function, way, and result)
- In copyright cases, detection of non-literal copyright, using e.g. tokenization tests, structural comparisons
Software reverse engineering:
Besides source-code examination, another focus of Software Litigation Consulting is examining the code embodied in actual products and services. This code is often more accessible than the source code, and often provides a different perspective from the source code.
Before source code becomes available during discovery, we can usually locate relevant elements embodied in, or steps carried out by, software/internet products and services. Software/internet products/services often contain the names of functions, structures, steps of processes, and so on — often even the names of source-code files. Both static and dynamic software analysis (“reverse engineering”) are employed.
Not only is reverse engineering or its equivalent required for a reasonable pre-filing investigation under Rule 11 and Local Patent Rules, but working directly with the accused product/service provides direction and focus for discovery, including source-code examination.
Defendants as well as plaintiffs often require direct inspection of the accused product/service, which provides crucial context to what is found in the source code. The role that code plays in the actual product/service may not be apparent from looking solely at the source code.
Since anticipatory prior art must by definition have been publicly accessible at the relevant time, looking at actual products/services will often be more relevant than a prior-art search focused on proprietary, closed-held, source code.
Some of the questions attorneys may have about source-code examinations and about software reverse engineering (including “Why bother with anything other than the source code?”, “How can defendants benefit from reverse engineering the relevant software?”, “Is the kind of element-by-element information I need really available without the source code?”, and “Is it permissible to reverse engineering software, even for litigation purposes?”) are addressed in the FAQ.
Recent CV available here; a confidential list of past cases and clients is available under a non-disclosure agreement.
LinkedIn profile here