Slashdot Mirror
Abusing the GPL?
"How, you may ask?
Integrate the highly useful GPL code we're eyeing into our only slightly more complex (but much more lucrative) project, thereby saving us at least 30% of the coding involved. The company then go all the way to production with it, but instead of finally compiling the actual project for distribution, they instead compile a bunch of incomprehensible gobbledygook that just happens to compile to the same bytecode. You know the game: globally replace every function name, variable name, and so on from our code with nonsensical names (or random characters), remove all of the comments, and any other form of obfuscation they can introduce. They will then GPL the obfuscated gobbledygook, which isn't much more useful to anyone than reverse-engineered bytecode would be (it is a complex project). 'Voila!' All the benefits of a huge GPL project and countless thousands of volunteer hours and unreadable, incomprehensible source tree.
For the record: I do not think this is right yet, I have not been able to find any precedent for why the GPL should protect against this kind of abuse.
I'm not trying to snitch on my company -- or lose my job, which is why I am posting anonymously -- but hopefully some lawyers out there could point out some iron-clad legal reason preventing this sort of thing. I've read the GPL through at least a dozen times since yesterday, and so far it looks like our lawyer is right. I have not found any relevant linkage either, as I have mentioned. Links to extended legal analyses of the GPL from a technical standpoint (if any exist) would be the most helpful. All help is appreciated."
If you take some code and switch out all the variable names and change the spacing around, it's still the same code. If your lawyer is advising you differently, I'd be very suspicious of his motiviations.
"We returned the General to El Salvador, or maybe Guatemala, it's difficult to tell from 10,000 feet"
To find out whether the gobbletygook you distribute is source code or not is simple: if you normally add features to the program by editing the gobbletygook, it's source. If you instead edit the stuff that you compiled to gobbletygook and then recompile it, then the stuff you distributed isn't source and it's a clear-cut GPL violation.
If this isn't the form your company prefers for doing their own internal modifications, then this isn't the source code!
Nowhere does it say that that code has to be non-obfuscated. Nor do I think it should. Do we really want to try and formalize that gray area between "obfuscation" and just plain "sloppy code?"
Not all of the code released under the GPL is what we would consider "good code." By that, I mean people release all sorts of toy projects and junk code under the GPL, for learning purposes. They use bad variable names and inefficient algorithms, but when do we start to consider code "obfuscated?" And more importantly, do we want to leave it to a lawyer to make that decision for us?
I say if you're really concerned about it, then leave the company. Otherwise, just write it off as mean-spirited. There's no law against being mean. :(
Like woodworking? Build your own picture frames.
Pretty boring stuff, but the overall point is that once the end product is GPL'd, it won't take long for someone in the bazaar to figure out a meaning for "asdfgh", and do a s/asdfgh/meaningfulName/g through the whole thing. Or even figure a way to diff it with the original source.
As long as it's GPL'd, the source will be available, and it'll be figured. You're wasting a lot of your time (and the rest of the community's) for very little reason.
No matter how complex your obfuscation, it's likely much less complex than, say, CSS or DES was.
jer
We may be human, but we're still animals
- Steve Vai
As far as I can tell, AINL, as long as you do in fact release the source code (and all linked pieces... must be careful about this), you are in compliance with the GPL, even if the souce code has been obsufacated as much as possible. Just remember though, *everyone* will get to see this source code. They will either know that 1. You are ripping them off by 'working around' the GPL. Or 2. Think your company is staffed with the most incompetent imbecil programmers anyhwere. So my question for you is... Why would *any* company want to release something that makes them look bad??? What exactly is the advantage they think they will get from this?
Why did it take so many posts for someone to point this out? Do people not read the GPL?
What a day to be without moderator points...
For those too lazy to read the whole thing, read section three, point #3 very carefully. Just because something compiles does NOT mean that it is source according to the GPL. That you would not do development on the obfuscated gobbledegook clearly shows that the obfuscated version is NOT the preferred form for modification. I would be highly suspicious that your lawyer is insufficiently anal when reading contracts if they missed this.
As for precedent, can anyone find a discussion of GPL'ed yacc/bison grammars? This would fit exactly the case above - the original source that must be distributed is the .y file, not the result of compiling the .y to a .c file. Unfortunately, I don't think that anyone has ever been tempted to rip off a GPL'ed grammar.
Although logicaly it doesn't sound like a violation of the GPL because you still can see the source code. I question the motivation. How would this benifit your company? The source will still compile right? It still can be obtained free. right? This just seems silly. The problem people have making money off of GPL'ed software lies not in the open source code but in the fact that people can get for free what you are trying to sell.
I mean when was the last time you looked at the source of a project that you just wanted to use, not develope.
(BTW, I am not a legal advisor. This is my understanding of the GPL).
If you are including other people's GPL'd source code in a program which you distribute, then you must abide by the terms of that license. Section 3 of the GPL is precise enough to disallow scrambling the source code:
There is nothing to stop you changing all the variable names, or the style of someone else's code. However, if you distribute a GPL'd binary then the source you distribute with it must be the source that you prefer to use for modifying the program yourself. You may be called upon to prove this in a dispute.
For reference, section 3:
The primary question of the article was "Is this legal or actionable with respect to the GPL?"
Even if the FSF knew about it, what could they do? There has to be a clear violation of the wording of the GPL, not just some gut reaction.
So the question stands: What can be done about this type of situation given what we know?
If there is something that can be done, then talk about reporting them.
FWIW: The BSD advertising clause would require at least one comment remain in the code, the original authors name. That would at least give someone a hint as to where the code came from when trying to interpret the "garbage" source.
There is nothing so silly as other peoples traditions, and nothing so sacred as our own.
The GPL states:
That term was written to prevent exactly the sort of obfuscation the attorney is proposing. Obfuscated code is demonstrably not the preferred version for creating modifications. So, what is being proposed is a GPL violation, and your company's attorney missed that part of the license. The talk about incidental resources isn't germane, it actually seems to be intended to confuse, because what is being proposed clearly is a derivative work, and the company attorney is acknowledging that when he suggests that the obfuscated code be GPL-ed.But there are simpler remedies than legal ones. If the free software developer community hears about a product using obfuscated code to circumvent the GPL, they will retaliate by creating a non-obfuscated version and using it to compete with your company's product. They are experienced at reverse-engineering, they have excellent tools for code reformatting and analysis, and there are a many programmers who will be angry enough to work on this.
If your employer wants to unashamedly take advantage, they are simply buying a lawsuit. The free software community does have the resources to bring one - it would probably be brought by law professor Eben Moglen of Columbia University. He wants more legal tests of the GPL, and would love to make an example of your employer. Don't go there.
Bruce
Bruce Perens.
From my reading, that is not the problem. It appeared that the company did release the code with source as GPL along with their product. They just obfuscated it before releasing it. That is not directly a GPL violation.
There have been cases before of obfuscated GPL code (Some video drivers in the Linux Kernel I believe) but those were original source from the manufacturer.
This article is about taking someone elses GPL code, obfusacting it, then re-releasing it with GPL intact.
There is nothing so silly as other peoples traditions, and nothing so sacred as our own.
I just had an idea.
What if they claim that the obstafacation (sp?) is part of a copy-protection plan and that anybody whom writes a program to un-do it is violating the DMCA.
Could they sue even though the code is in fact GPL?
-J
That is a scary notion.
It could lead to a situition where corps. co-opt open source programs, embed a password protection scheme,than obfascate. They could then outright take all the code they want and make a program to give away. Then could then make money off of selling the passwords. All will being covered by the GPL and DMCA.
I don't see how this violates the spirit of the GPL, since there are no provisions in it for the quality or readibility of code.
.asm file that is just the disassembly of your binary isn't very useful for preserving the right to modify the program. Neither is deliberately and cleverly obfuscated source.
The "spirit" of the GPL is about being able to make modifications to the code. That is one of the rights that the GPL is trying to preserve. It isn't just about being able to get a free copy of the code you can compile (and if you're lucky for different platforms).
As at least a dozen other posts under this article have already said, there is language in the GPL providing for quality -- or at least editability. The source must be in the "preferred form" for editing. Because releasing a
The authors of the GPL understood that "openess" depended on at least the level of usability that was present when the code was written. Hopefully we've cleared this up (and this guy's company lawyer has been sacked).
The enemies of Democracy are
Until they actually release this code, there's nothing the FSF (or anyone else) can do. Talking about copyright violations isn't a crime, and there's a good chance management will come to their senses. As long as these people don't do anything immoral, I don't see anything wrong with working for them.
Threatening mass resignations from engineering, btw, is one tactic I'm currently seeing used to prevent a GPL violation at another company. Buyer's market though engineering talent may be right now, I expect it'll be effective -- turnover is just too expensive. Quitting right away (as soon as idea is raised) -- simply put, why?
IANAL, etc... etc... yadda, yadda, yadda.
The company then go all the way to production with it, but instead of finally compiling the actual project for distribution, they instead compile a bunch of incomprehensible gobbledygook that just happens to compile to the same bytecode.
You know the game: globally replace every function name, variable name, and so on from our code with nonsensical names (or random characters), remove all of the comments, and any other form of obfuscation they can introduce.
They will then GPL the obfuscated gobbledygook, which isn't much more useful to anyone than reverse-engineered bytecode would be (it is a complex project). 'Voila!' All the benefits of a huge GPL project and countless thousands of volunteer hours and unreadable, incomprehensible source tree.
Here is my take:
Other things to take into account:
Conclusion?
Bad idea. VERY bad idea. Release code under GPL, play nice, and nobody gets hurt... (wink! wink!)
IMHO, any company who tries that kind of stunt is going to end up on the trash-pit of dot-coms faster than you can say "GNU General Public License".
The right to offend is far more important than the right not to be offended. (Rowan Atkinson)
Yes, it does:
'The source code for a work means the preferred form of the work for making modifications to it.'
Incomprehensible gobbledygook does not the preferred form make, any more than machine code.
What a lot of people appear to miss a lot of the time is that the GPL is _not_ one of those 'thrown together in a week' opensource licenses. It was developed over several years, and reviewed and rereviewed by the FSF legal counsel. It doesnt have holes like this.
Newbie lawyers looking at it for a few hours always misinterpret it. They dont have the technical savvy, nor the persistence to grasp the actual meaning and how thorough the GPL actually is when it comes to accomplishing its task.
The current MySQL AB/Nusphere legal issue isnt the first court case on the GPL because nobody has tried to violate the GPL before. It's because everyone else has realized they dont have a chance in court, and have given up rather than trying to persue a case which their lawyers have eventually realized they will lose.
It would be hard to write an anti-obsucation clause I imagine
Not that hard; in fact, it's already been done. The GNU GPL, section 3, states: "The source code for a work means the preferred form of the work for making modifications to it." I don't think any reasonable U.S. district court judge would consider robo-obfuscated C to count as the "preferred form" for that purpose. See #3117740 for another explanation.
Will I retire or break 10K?
1. Is it in violation of the GPL? This question is not a simple one, but such actions may very well be violation of the GPL. If this matter reached court, the question would center on whether the process applied to the GPL'd code constituted part of the process to create the derivative work, as derivitive work is defined in the GPL. For example, an expert might argue that code obfuscation can be part of the compilation process. It is oversimplified to say that laws are reinterpreted on the fly to capture the intent of the law. What is true is that these sorts of questions - for example, what constitutes compilation - are likely to be viewed in a manner which assists the obvious intent of the applicable contract/law.
2. If it is a violation, can it be proved? Probably. Our company works for lawyers on code plagiarism cases all the time. There are many algorithms you can apply to show statistically significant relationships between a body of code and its obfuscated counterpart. The same should be possible with bytecode. Once a reasonable basis for suspicion is established, plaintiffs could get discovery of the company's code repositories and depose employees under oath.
Christian Hicks
Elysium Digital, L.L.C.
http://www.elys.com
It might be gramatical, but it's not germane. I suspect it was intended to obfuscate.
Bruce Perens.
I can think of a few other, better ways, to use GPL code in commercial projects without pressing everyone's ethics button so hard. Better engineering, better PR, less work. Is that so hard? Sounds to me like the lawyer wants to have a few years steady work, and your CEO is too preoccupied with being evil.
- - - Non Caffeine Drink or Drink Error
Go to a public library. Logon to the internet terminal found in most public libraries. Create a Hotmail or Yahoo Mail account. Use that account to E-Mail the FSF with your company's name, the project's name, and as many details about the project as you can without personally identifying yourself.
Then, later, you can sleep like a baby, knowing you did the right thing.
The next Slashdot story will be ready soon, but subscribers can beat the rush and slashdot the links early!
Look, there IS another option.
Without knowing the details of what GPLe'd application is involved, it's hard to give good advise, but you may be able to talk to the authors of the code to re-issue the code under an additional license. Maybe the authors would be willing to release the code under the BSD, LGPL, apache, or other license in exchange for a few bucks...
Of course if this is really old GPL with hundreds of authors this becomes difficult. You would need approval from all the contributers.
First of all, IAAL. Second, the GPL's definitional distinction between source and object/executable form relies on two key terms that cannot be objectively measured: "preferred" and "normally". I defy you to provide me with objective metrics for measuring what is "normally distributed...with the major components...of the operating system on which the executable runs." Equally imnpossible is a definitive response to the question "what is the preferred form of the work for making modifications to it?"
In order to impart meaning to the GPL distinction between source vs. object/executable, one must go on a fact-finding parade to measure industry practice, and other wishy-washy standards. In the context of a dispute over a GPL'd bit of code, you can be damn sure that the GPL will collapse under the weight of this fact-finding process, and that the party with more patience and money will win that battle.
There are some things that lawyers understand better than geeks, believe it or not. We are (generally) excellent at spotting weakness in prospective arguments. In the case of the GPL, there are drafting holes big enough to drive a Trident submarine through. I've said it before, and I'll say it again: the GPL won't hold water in a dispute. The reason no one has given you any precedent (as per your request) is that the GPL has not been truly tested in court. Since the GPL eschews the lessons that lawyers have learned about drafting in the past (largely in order to score points with geeks by being colloquial in manner and sounding un-lawerly), it cripples itself with imprecision and ambiguities. The weakness in its core definition of source vs. object/executable is merely one of many fatal flaws in the document. To be perfectly frank, the GPL is a POS contract and I would arguably be liable for malpractice if I advised a client to use it for reason other than their unbending adherence to open source dogma.
In conclusion, you are likely to see many companies "abusing" the GPL. Rather than use the loaded term "abusing", I would prefer to characterize this behavior as "exploiting" the unsophisticated and niave drafting of the GPL's language.
Since I said "IAAL", I must also say that the above does not represent a formal legal opinion, that I do not represent you (the reader) as your lawyer, and that you should not treat this message as my legal advice to you. Laugh all you want -- I'm just sticking to my ethical directives, kids.
I'm not a lawyer, so don't use this as legal advice. Instead, you (the author of this slashdot article) may want to show it to your company's lawyer and suggest that he track this down.
According to this link, there is a case called "Whelan" that established that duplicating the detailed structure of a program was copying of expression rather than ideas, and therefore copyright infringement.
Also, I remember reading a very good article about ten years ago by law professor Pamela Samuelson, I think in Communications of the ACM or some other ACM publication, that talked about this decision and mentioned "detailed structure and flow", which would make the case for infringement even stronger.
Finally, I recall reading somewhere, perhaps in that same article, that there is some common law rule that the standard of similarity by which copyright infringement should be determined is supposed to correspond to how much access the alleged infringer had to the original work. In other words, if the alleged infringer had easy access to the original work (e.g., had carefully read the original GPL'ed source), then the standard for proving infringement is supposed to be easier.
Again, I'm just a layman. Don't use this as real legal advice.
I'm not an expert with legalese, but:
First arent all the copyright notices inside comments ?
Removing comments with the copyright notices would immediately violate T&C section 1. (while indicating acceptance of the whole document as per section 5), but then you aren't allowed to remove the comments. The obfusciation is seemingly permitted so long as the copyright comments still remain along with additional comments documenting the changes as required by section 2.
The obfusciation is seemingly a process of derivation, that is you start with GPL product and do some M-x replace-string's... This derivation process means that the "proprietary intellectual property" is still GPL'ed...
The GPL does NOT apply to sections not derived from GPL code, but only when they are published apart from the GPL portion. when the whole package is published it is still GPL'ed by inclusion of the GPL code (does anyone remember the Nvidia driver issues?)
Also according to section 5 the fact that you edited the GPL code at all indicates acceptance of GPL terms and conditions. Failure to accept prohibits you from making modifications (such as the string search and replace described)
The whole process seems expressly in violation of section 4, but i am no expert...
What I fail to see is how anyone can avoid GPL except by producing clean-room-code. I seem to recall Nvidia having this problem with their drivers a while back.
As an aside, isnt "chicken noodle soup" less than 30% chicken by volume? (but it is still considered a chicken product.) Your company's project might be 30% GPL code that was heavily edited (IMHO the only real weakness in the GPL is no "real" definition of "derived", however the common meanings of derive include "to trace the deveolpment of", which has been done...)
A couple of questions: Is it possible to write a perl/awk/sed script (or otherwise algorithmically describe the obfusciation? (since global replaces are used i would dare way yes...) If this is true then an argument can certainly be made that the work was "translated" from "ANSI c++" to "ANSI c++" (hasnt anyone done english-to-english translation between say a lawyer and an engineer? or perhaps heard of such things?). This translated copy would seemingly be covered by section 0 and all other sections (as incorporated into the defitition of modification)
just a few cents worth
-j.
I think that this is a distinction that is much easier to make than the previous one you mentioned. All you have to do is to go to the computers where the people are actually writing the code and see what form of the program they are modifying. If they're working on the code in a format different from what is distributed, it's an easy case that the form that's being distributed isn't the preferred form for making modifications. That's especially true if you can find:
You're correct that this is not an open and shut thing, but it's not an intractable one, either. Most people have fairly sensitive BS detectors, and they're going to be able to tell that code that's been deliberately messed with to make modification more difficult is not in the preferred format for making modifications. All you have to do is show that a deliberate attempt has been made to obfuscate with the code and you're set.
There's no point in questioning authority if you aren't going to listen to the answers.
What benefit does a company accrue to taking someone's work, obfuscating(sp) it and then re-releasing it under GPL as one's own? Unless they are not actually intending to release as GPL..
Well, assuming what you say is correct, the benefits are few... The chances of getting caught are moderate, but if you or one of your staff is laid off/fired/quits then the word will get out and make its way to the original authors.
Nobody needs to "squeal" either. Say I write a lot of code for GPL's project X and this company comes out with product X' which is almost the same, but better. Their code is extremely obscure as well...
I might out of curiosity, run one of those web-based code checking tools. These are designed to find cheating students and do not require similar variable names, etc.
If caught the costs would be painfully high. I think most software companies would rather face a ravenous pack of lawyers than face the savage hordes of a jilted Open Source community. Every day operations would become difficult due to clogged email/phone lines, not to mention that your good corporate name would be mud.
The B/C analysis is vastly in favour of crediting the original authors. I think your managers and your lawyers are playing dice with your company's future. If I was a share holder (let alone an OS geek or an employee like yourself) I'd be quite pissed.
Good luck!
-b
IANAL so this is only from my observation:
Several posters have pointed out that obfuscation is a violation of GPL, or at least the spirit of the GPL.
Unfortunately, until your company actually releases a product based on obfuscated GPL code (commits a violation), you can't take legal action in the courts; you can only get a GPL-friendly lawyer to send nasty cease-and-desist letters.
In other words, you can't stop it until it's too late. And if you do sue, the copyright holder (the creator of the GPL code which was borrowed) will probably have to be named as a plaintiff, as the violation was commited against HIS copyright, or possibly the FSF as a plaintiff's representative yadda yadda yadda. YOU probably will not be able to file suit as a plaintiff directly, unless somehow you can do it as a representative of the party claiming loss.
If you do nothing else, inform the writer(s) of the original code of your company's intentions.
Give me my freedom, and I'll take care of my own security, thank you.
Of course, as a lawyer, you should also realize it is ten times more expensive to defend than to sue. The costs of responding to discovery, alone, can easily hit six figures. And, (personal opinion) the obviousness of the obfuscation would probably be enough to prevent dismissal. So, the real question is not "could the Company in question win a suit," because we all know that in the lottery we call Trial by Jury anyone could win on any given day. The real question is "could the Company lose." A loss in court might result in the inability to sell their product for some period of time, or damages to the extent of their sales. If the company is small enough, this could mean the end of it. Is it worth the gamble?
Milo
The GPL is a license that, when I apply it to my code, says that you may take my code, modify it (or not) and redistribute it. However it places the restriction that you MUST also distribute or offer to distribute the source code for anything you compile my code into.
This is why the GPL defines what source code is. And source code is HUMAN READABLE. Thast the point of source code. Code that has been preprocessed in some way, even if it is not a machine readable binary, is NOT source code unless it is in a human readable and inteligable language.
I do believe that this issue is specifically addressed in the GPL (along with a few other situations, which is why the GPL is so damned long).
This is definitly a violation of both the letter and the spirit of the GPL, and I urge the person who asked this question, or anyone else working for this corperation to blow the whistle on this project. It is a direct attempt to subvert the free software community.
-Steve
"I opened my eyes, and everything went dark again"
Eh. It doesn't really matter. What does matter is that he's got a legal theory as to how the GPL can be sidestepped. It might not hold up in court. But that doesn't matter until it gets to court. There's no Bad Law Fairy who's gonna come out of the sky and put things right. Somebody is going to have to mount a legal challenge to this abuse. That somebody has to have legal standing in the case and deep pockets. Now, don't all raise your hands at once!
OK, I just ran out of irony. Look, the mod system worked -- maybe not as fast as you liked, but it did. Don't feel bad because you didn't get to put on your Arnold mask and mod all the lamers down. It's just a damned filtering tool, not a way to Rebalance Universal Morality.Now, the fact that this intermediate bytecode is legal C or whatever other language the original was written in doesn't make it source. It just means that that is the internal syntax of this intermediate stage. This is because the defining characteristic of source code is that it is human readable. It is what the developer wrote and would use to modify it himself. WHen you preprocess this in such a way that it is no longer suitable for human reading and maintaining, it ceases to be source...and ceases to meet the GPL source requirement.
I highly recomend that anyone who is going to talk about this actually READ the GPL
From the GPL:
-Steve
"I opened my eyes, and everything went dark again"
I recall a friend of mine who worked on a project that was designed obfuscated in the first place. Var names like vEh45c01, etc.
all proprietary, all aobscure, god forbid if the guy who designed it were to have an accident.
That said, would keeping the clear code represent a legal obligation? Since after all, the clear code is really the source, not the obfuscated stuff that you compile from.
"It is a greater offense to steal men's labor, than their clothes"
Yes, that would be one test for "preferred form", but there are others and the other side of any dispute will present them. The point is that the standard that you propose does not necessarily follow from the language of the GPL. In other words, your standard is more suitable than the GPL language. Of course, at trial, the credibility of your engineers and/or anyone testifying about their procedures will be at issue.
You may be a lawyer, but no other lawyers seem to agree with you.
:) When the company goes out of business it'll show they were lying.
I went across the hall at work yesterday and asked two lawyers who I often see over lunch about this. They said that while "preferred" and such terms are often fairly vague and cases hinge on those, in this case, where you can simply show the inability of the company to use the obfuscated code, and the obfuscating programs used, that it's dead simple.
Too bad modern judges can't hand down rulings that really cut to the heart of the problem...
Ruling that the company must delete all other source code and forever maintain the project using only this source code and other code in this form would quickly show if this was the preferred method.
(With creative and honest judges we could get by with a lot less of your type.)
While some judges might let you bring your industry usage of the term "preferred" to bear on the meaning and intent of this contract, just as many other will demand that the agreement be interpreted "within the four corners of the document". And why should one have to resort to an "industry standard" definition, when the question could easily have been addressed in the agreement itself? And how will you go about proving that your usage of preferred is widely-accepted? Will you bring in witnesses? How many? How many will your adversary bring in to prove that your usage of the term is not "industry standard"? How long will the parade of witnesses take? How much will it cost? Why wasn't this dispute clarified in the agreement before all the lost time and money? Do you have answers to these questions?
It's not a ploy, it's an assurance. Before the FSF is going to commit money and resources to defending a project, they want some proof that the author is truely commited to Free Software. Authors have refused to persue GPL violations in the past, and the FSF doesn't want to let authors pick and choose who can violate the GPL. They also do not want to defend a project that could potentially change it's liscence and become proprietary software sometime in the future. As long as the FSF holds the copyright that can't happen.
So while you are right, they could defend people without assigning copyright to them, they are trying to protect the interests of Free Software, and protect hemselves from being abused.
Firstly I think it's not so easy to define source at all. I read some of the transcripts of the 2600 case that dealt with arguing that Code=Source=Speech. It was really revealing - defining source is a slippery issue.
Secondly even if your definition - must be human readable - is accepted, there are humans who can read machine language, in hex (I'm sure we've all got anecdotes about our favourite guru programmer doing just that). And to be honest most programmers, with a little effort, could train themselves to do the same.
Finally - you're assuming the obfuscated text is no longer source and that therefore there is a separate text which is the 'real source'. Let's think about how someone normally forks a GPL project, something like -
- take original GPL'd source code
- make modifications
- release new code, with source, and acknowledgement of original authors
But the GPL doesn't AFAIK require the release of the original source - only the source for your new version. Releasing the original code is the responsibility of the authors of the original project.
So in this case, obfuscation is part of the modifications, along with inclusion of some home-grown code (the original GPL code was only 30% of the whole right?). So legally how is there a difference?
However, these points in themselves lead to reasons why this approach would be unsuccessful. Namely,
- if hex machine code is human-readable then obfuscated C certainly is. Plus if it's been obfuscated mechanically - it can be de-obfuscated mechanically. Partially anyway.
- they have to acknowledge the original code's authors and therefore the original project. People can compare the obfuscated code with the original code and figure a lot of it out.
Using a combination of these I can forsee that it would be possible to generate a completely 'plain source' version and keep it in step with the obfuscated one, with relative ease.
To sum up - I think legally they can do this, but I doubt it will gain them much advantage.
But I am not a lawyer.
Personally, I think this would be a rather easy case to prove if anyone chose to pursue it.
... technically, at least).
A context diff of the "obfuscated" code against the code it's derived from would rather quickly show that the only changes from one to the other was symbols and the lack of comments. Unless, that is, they resorted to some rather serious Obfuscation like operator and function overloading, or trick use of preprocessor errors, in which case, a diff of the preprocessor output from the two code trees would also damn the offender pretty quickly.
I AM a (recovering) Lawyer (I am non-practicing) and I would advise your company that they are playing with fire by trying this. You didn't reveal which GPL Code your company finds so useful, but there are MUCH smarter ways to play this game, especially if the authors of the code you like so much HAVE assigned their copyright to the FSF. (See, FSF v. NeXT Computer, (over gcc) for instance).
I question the degree of "tech-savvy"-ness of your company's counsel if he's advising them to go "full speed ahead" on such a transparent, bad faith abuse of the GPL (can't call it a violation
utter rubbish
You may have somehow missed out on this, but lawyers are paid to disagree with other lawyers. No matter what your lawyer says, I guaran-goddamn-tee it that every other lawyer on earth will disagree with him if I pay them to do so.
The question you should be asking your lawyer is not "What do you think this contract means?" but instead "Do you think you could win this case?"
On second thought -- don't ask your lawyer if he thinks he could win the case. The other thing lawyers make money from is claiming to be able to win cases for you. Ask some other lawyer if he thinks your lawyer could win the case after making it clear that you can't afford his services.
Proud member of the Weirdo-American community.
It's not so much that "preferred form" is obvious, it's that "the preferred form" is obvious. Note, not "a preferred form". The common meaning of "the preferred form" allows for exactly one form to fit this description. In other words, out of all of the available forms, the one that is the best possible form for modification is the one that has to be distributed. Quite clearly, if the company is continuing to modify the program in form X, then form X is, prima facie, the only possible form that fits the phrase "the preferred form".
The only way this could be negatived (yes, that is a verb in lawyerspeak) is by demonstrating that the form used for development is a form not convenient to others, and the translated form is actually preferable for those others.
IANALY, but I did top the year last year, and this is a simple question of interpretation that a first year law student could deal with.
Any lawyer who opines upon such a scenario in the abstract is likely committing malpractice. The Devil is in the details. However, it seems apparent to me that the risk of getting such a blatant end-around probably wildly exceeds any perceived benefits derived therefrom.
I can think of a zillion reasons why the proposition described above would not work, but there simply isn't enough information to answer the question in slam-dunk fashion. Suffice it to say, however, that I am seriously doubtful that such a trivial pretense as a byte-code or object-code copy produced by other means could avoid a claim for copyright infringement.
Even so, to the extent that an "on the edge" defense is being prepared, the defendant had better be right. With such willfullness, a prevailing plaintiff is likely to obtain substantial statutory damages, perhaps as much as $150,000, an award of attorney fees, and an injunction against release of the product. If they made profits from the product in excess of that amount attributable to the taking, a prevailing plaintiff could elect for the greater amount.
In short, a commercial entity that tries to do so may well be poorly advised. But once again, I don't know enough particulars to make a determination one way or the other.
The question they have to ask themselves, "do I feel lucky?"