|
Code-cracking is the art of reverse engineering software
for the purpose of re-engineering it to do something not
originally intended. Nowadays, the majority of cracking is
done to bypass software "security". Developers incorporate
security measures within their software to thwart piracy and
prevent unlicensed use. Crackers reverse the software,
disable its "security", and release a crack which
conveniently allows others to do the same. Users download
crack and apply it to software in order to obtain extended
usage without the licensing restrictions imposed by its
developer (usually payment). Online libraries of crack
provide users access to commercial software without paying
for it. While the use of crack is illegal, its distribution
is not. Since cracks do not contain any copy-written code
from the products they crack, web sites and other
distribution channels freely continue their distribution.
Developers combat cracking to obviously protect profits and
ensure proper licensing of their products. It has been said
that more than one third of software running is unlicensed.
While hard to imagine that this figure could come from
anything beyond guess work, it is nonetheless a believable
and perhaps conservative estimate.
A percentage of crack users are actually paying customers
dealing with unforgiving copy protection. Lost product
disks and/or activation codes along with poor or no product
support can leave users with little recourse. While the
percentage of crack users that don't pay for software don't
give their reasons, for some, software may be unaffordable
but necessary.
Hard core crackers hack million dollar protection schemes
for the enjoyment of the puzzle. Those that post their
cracks additionally receive recognition from fellow
crackers. Their dissertations explain the tools and
fundamentals to newbies who may be learning to crack for the
puzzle, the recognition, or the crack itself.
While forums, knowledge bases, and "crack-me's" educate
would-be crackers, information on protecting software is
scant and usually written by crackers themselves. New tools
have added to the capabilities of the cracker but new
methods of fighting crack have been slow to develop. There
are many commercial "protections" available to developers
but very few, if any, have withstood the menace. The
reversible nature of software simply makes protecting
extremely difficult.
A fresh perspective has lent itself to a new technology
that is changing all of this. Protection comes, not from
one method, but many. By populating multiple protections
across a program's entirety and establishing in the
software a unique dependency on each, developer can now
create what might be called "a cracker's worst nightmare".
In the same way that nature replicates unique copies of a
single design, Miracode duplicates itself with one purpose
but many results. Establishing real dependencies on these
results creates a protection so intertwined with software
that one cannot be removed without severe detriment to the
other.
MIRACODE protections or "security kernels" are singular in
purpose but unique in their method, code, and data. None is
dependent on the other and nothing is shared between these
free agents. Each has a unique imprint and each supports
program in a unique way. Violating a program's integrity
severs that support and software becomes non-operational in
the broadest sense, effectively stalling developer's
distribution vehicle - "joy ride's over".
Revolutionary also is the way that these protections are
incorporated into software. Traditionally, program is
either encapsulated or linked to its protection. MIRACODE,
on the other hand, is injected directly into source code
files and becomes embedded within a program's core
operations. The lack of any common denominator between
"Security Kernels" effectively removes the ability to find
them. Miracode protections support basic program operations
and will fail only if software is engineered to violate
trial licensing. When this happens, program instability
grows to significant levels making continued usage
impossible.
Credits
by Rob Hock @ Miracode
... learn more at http://miracode.com |