New Fan Works Old Fan Works Zelda Series Multimedia Features Interactive Site Info

Kasuto's Ramblings

Skip an Ad and Go to Jail
The problems with the Digital Milennium Copyright Act

    Have you paid attention to the new laws going through Congress in the last couple years? One particular law that has caught my attention is the infamous Digital Milennium Copyright Act. This law was intended to protect copyright holders from infringement by the many technological advances of today. Essentially, it reinforces the old copyright laws and applies them to modern times. This sounds great, doesn't it? There you go, jumping to conclusions again. Ever since it was passed, this law has been denounced by freedom-of-speech advocates and computer geeks (myself included). In reality, this law is nothing but legalise nonsense. I have read it myself, and it is self-contradictory. I always thought the purpose of laws was to serve the people, but this law only serves the giant entertainment super-corporations. The law turns billionaire companies into whining brats and ordinary citizens into hardened criminals.
    What has got me so upset about this law? It's the fact that it abridges my right to free speech. The main point of this law is to prevent computer hackers from creating any device or computer program that can circumvent or defeat encryption on copyrighted materials (emphasis on DVDs). According to this law, it would be illegal for me to write a program that could decrypt DVDs. Sorry to say that this has already been done. The program, called DeCSS, has been out for quite a while and caused a lot of hooplah. According to the lawyers who tried a case against the people who wrote DeCSS, decrypting a DVD is terrorism. That sure makes a lot of sense. One day somebody is descrambling a movie, the next day he's hijacking airliners. The big movie industry praised the new law because it will put hard-core cyber terrorists like the guy who wrote DeCSS behind bars where he belongs. That'll teach people to exercise their creativity. That must be what our country stands for: Freedom for all, except for those who do something that the movie industry doesn't like. All I ever hear is "copyright infringement", but no one ever talks about it from the opposite point of view. The people who originally created the Content Scrambling System (CSS, what prevents DVDs from being copied) issued a challenge to the world. They were so sure that their code was unbreakable that they offered a reward to anyone who could crack. No much later, the code was cracked and now they're trying to put him in jail. If you ask me, they brought it on themselves. The movie industry was arrogant, and it blew up in their faces. Serves them right.
    Another thing that is covered by the DMCA is things like advertisements on DVDs. The movie industry has plans to put certain ads and previews onto DVDs that you have to watch and you cannot fast-forward through. Rest assured, if this ever happens, it'll take a week for someone to crack it. According to the law, finding some way to skip the ads is illegal and you can go to jail. I never knew that I could go to jail for watching my own movie. But I guess the government cares more about the movie studios, who kindly give millions of dollars to the political parties, than the people who elected them.
    Of course, you know the reason why the entertainment industry pushed so hard to pass this law. They're afraid that if people can copy DVDs, they will compress them and post them on the Internet, creating a "Napster" for movies, and millions of dollars in lost DVD sales. The people who make these accusations claim to know what they're talking about and that they're "experts". I'm willing to bet that none of these lawyers and movie execs have even tested these programs that can compress a DVD movie. Let me give you a little inside info about this stuff. For a long time, there have been dozens of programs (geek term: "codecs") that can compress movies. I have just about all of them on my computer. These codecs are the same thing as MP3s, only for movies instead of just sound. They take a very large movie file from a DVD (about 7-10 GB) and squeeze them down to 650 MB or less. The movie industry didn't worry about this until their content scrambling system was cracked. Now people could take movies off a DVD (much like "ripping" a music CD), and compress them into smaller files (just like MP3s). They predict doom-and-gloom like new Napsters where people can download any movie they want. It happened with CDs and MP3s, and now it's going to happen with DVDs and DeCSS. At least, that's what the big corporations say. Allow me to put in my two cents. They people who make these allegations are complete idiots, morons, ignorant, and arrogant (not to be confused with Al Gore, who invented the Internet). They worry so much about people downloading movies of the Internet willy-nilly, and losing millions of dollars because people won't buy the DVDs anymore. Well, I decided to see just how easy and widespread movie swapping could become. In my computer, I have DeCSS, DVD rippers, and video compressors to do exactly what the movie industry is complaining about. Let me run you through the process.
    1. Ripping and decrypting the movie. This copies the movie from the DVD disc to your computer and descrambles it. It takes about a half hour or more to copy the movie. The average movie is around 7 gigabytes. You'll need a lot of hard drive space.
    2. Various editing. This includes stuff like cutting out previews and other miscellaneous junk. Not difficult.
    3. Compressing the movie. This is the hard part. Like I said before, there are many codecs out there that will compress your movie. The most common DVD-copying codecs are DIVX ;) and MPEG-4. With it, you can squeeze a movie from 7 GB to 650 MB. That's a HUGE difference in size. Boy, everyone should be doing this. If you can squeeze the file that small, you can copy a DVD movie onto a CD-R. This is what the movie industry is worried about (in addition to posting on the Internet). I decided to test this simple method of compressing a movie. Well, it's not simple. One thing you need to know about video compression is that fast motion doesn't compress well. So I tested it. I extracted a 100 second clip from the X-files movie (which I bought). I purposely picked a scene with a lot of fast motion, the scene where the building blows up. Here goes the test. I had to select the codec, the audio compression, resize the movie file, crop out the letterboxing, and select from a list of compression methods. After finally doing that, I hit the Start button. It compressed at a rate of about 6 frames per second. It took about ten minutes to compress that 100 second clip. And the results were less than satisfactory. The motion was blocky and jagged, and the movie was jerky. It's hardly DVD quality, in fact, it sucks. If I were to compress the entire movie, it would take around 12 hours. So let's assume it takes twelve hours to squeeze that movie down.
    4. Now here's the part that the lawyers are whining about: distribution. You can put your compressed movie onto a CD-R and sell it, or you could post it on the Internet. Well, here's the truth. First of all, with the crappy video quality I've seen, I'm not going to buy a pirated DVD movie on a CD-R. I'd rather spend $20 and get the sharp image quality I want. Next, I'm not going to go and download the movie if it was on the Internet. Why? Imagine how long it would take. Assume the compressed movie is 650 MB. Most people still don't have broadband, so let's assume you're using a 56K connection. On average, you can get a download speed of about 3.5 kilobytes/second. At that rate, it'll take 51 and a half hours to download that movie. I don't know any Internet service that will let me stay connected for 51 hours. But what if you have a cable modem? Well, you can get download speeds of 50 kilobytes a second on average. That brings the download speed to around four hours. That's still a long time for an apallingly low-quality movie.
    Now you've seen the facts behind the scandal. The truth is, until the codecs get better, and everyone gets a cable modem, the threat of a DVD napster is unfeasible. I don't think it'll ever happen. I'm not going to waste my time downloading a moive when I can buy a high quality version for twenty bucks. There will be people out there who will pirate movies. Just like there are people who go into movie theaters and use a camcorder to videotape the movie and then sell it. Boy, I guess we should make camcorders illegal because people can use them to illegally distribute copyrighted movies. We should ban VCRs because people can illegally record movies off TV or copy other tapes. Just to be safe, we should ban computers because that's what people use to crack the encryption on movies. Oh, while we're at it, let's make steak knives illegal, that way no one will be able to use them to commit murder. Let's also ban gasoline and any other flammable liquid to prevent arson. Let's ban phones too, because con artists use them to scam people. Let's make paper illegal to prevent counterfeiting. Let's also eliminate baseball bats to reduce the number of gang fights. I could go on forever. Making it illegal to write programs like DeCSS in order to prevent copyright infringement is just like the above mentioned things. It simply doesn't make sense.
    Did you also know that the DMCA not only makes it illegal to write programs like DeCSS, but it also makes it legal. No, that's not a typo. One part of the law says it's illegal to create software that can defeat encryption. But in the next section it says that it is okay to create that same software to test the encryption. What is hacking other than research? The giy who wrote it was testing the CSS and he exposed its flaws. And what good is research if you can't publish your results? It's what all good scientists do.
    One last thing, according to the DMCA, anyone who posts the means to overcome copyright protection is breaking the law and can go to jail. So, if I post the code, I'm breaking the law. Oh gee:
 

/*
 * Copyright (C) 1999 Derek Fawcus
 *
 * This code may be used under the terms of Version 2 of the GPL,
 * read the file COPYING for details.
 *
 */

/*
 * These routines do some reordering of the supplied data before
 * calling engine() to do the main work.
 *
 * The reordering seems similar to that done by the initial stages of
 * the DES algorithm, in that it looks like it's just been done to
 * try and make software decoding slower.  I'm not sure that it
 * actually adds anything to the security.
 *
 * The nature of the shuffling is that the bits of the supplied
 * parameter 'varient' are reorganised (and some inverted),  and
 * the bytes of the parameter 'challenge' are reorganised.
 *
 * The reorganisation in each routine is different,  and the first
 * (CryptKey1) does not bother of play with the 'varient' parameter.
 *
 * Since this code is only run once per disk change,  I've made the
 * code table driven in order to improve readability.
 *
 * Since these routines are so similar to each other,  one could even
 * abstract them all to one routine supplied a parameter determining
 * the nature of the reordering it has to do.
 */

#include "css-auth.h"

typedef unsigned long u32;

static void engine(int varient, byte const *input, struct block *output);

void CryptKey1(int varient, byte const *challenge, struct block *key)
{
 static byte perm_challenge[] = {1,3,0,7,5, 2,9,6,4,8};

 byte scratch[10];
 int i;

 for (i = 9; i > = 0; --i)
  scratch[i] = challenge[perm_challenge[i]];

 engine(varient, scratch, key);
}

/* This shuffles the bits in varient to make perm_varient such that
 *                4 -> !3
 *                3->  4
 * varient bits:  2->  0  perm_varient bits
 *                1->  2
 *                0 -> !1
 */
void CryptKey2(int varient, byte const *challenge, struct block *key)
{
 static byte perm_challenge[] = {6,1,9,3,8, 5,7,4,0,2};

 static byte perm_varient[] = {
  0x0a, 0x08, 0x0e, 0x0c, 0x0b, 0x09, 0x0f, 0x0d,
  0x1a, 0x18, 0x1e, 0x1c, 0x1b, 0x19, 0x1f, 0x1d,
  0x02, 0x00, 0x06, 0x04, 0x03, 0x01, 0x07, 0x05,
  0x12, 0x10, 0x16, 0x14, 0x13, 0x11, 0x17, 0x15};

 byte scratch[10];
 int i;

 for (i = 9; i > = 0; --i)
  scratch[i] = challenge[perm_challenge[i]];

 engine(perm_varient[varient], scratch, key);
}

/* This shuffles the bits in varient to make perm_varient such that
 *                4->  0
 *                3 -> !1
 * varient bits:  2 -> !4  perm_varient bits
 *                1->  2
 *                0->  3
 */
void CryptBusKey(int varient, byte const *challenge, struct block *key)
{
 static byte perm_challenge[] = {4,0,3,5,7, 2,8,6,1,9};
 static byte perm_varient[] = {
  0x12, 0x1a, 0x16, 0x1e, 0x02, 0x0a, 0x06, 0x0e,
  0x10, 0x18, 0x14, 0x1c, 0x00, 0x08, 0x04, 0x0c,
  0x13, 0x1b, 0x17, 0x1f, 0x03, 0x0b, 0x07, 0x0f,
  0x11, 0x19, 0x15, 0x1d, 0x01, 0x09, 0x05, 0x0d};

 byte scratch[10];
 int i;

 for (i = 9; i > = 0; --i)
  scratch[i] = challenge[perm_challenge[i]];

 engine(perm_varient[varient], scratch, key);
}

/*
 * We use two LFSR's (seeded from some of the input data bytes) to
 * generate two streams of pseudo-random bits.  These two bit streams
 * are then combined by simply adding with carry to generate a final
 * sequence of pseudo-random bits which is stored in the buffer that
 * 'output' points to the end of - len is the size of this buffer.
 *
 * The first LFSR is of degree 25,  and has a polynomial of:
 * x^13 + x^5 + x^4 + x^1 + 1
 *
 * The second LSFR is of degree 17,  and has a (primitive) polynomial of:
 * x^15 + x^1 + 1
 *
 * I don't know if these polynomials are primitive modulo 2,  and thus
 * represent maximal-period LFSR's.
 *
 *
 * Note that we take the output of each LFSR from the new shifted in
 * bit,  not the old shifted out bit.  Thus for ease of use the LFSR's
 * are implemented in bit reversed order.
 *
 */
static void generate_bits(byte *output, int len, struct block const *s)
{
 u32 lfsr0, lfsr1;
 byte carry;

 /* In order to ensure that the LFSR works we need to ensure that the
  * initial values are non-zero.  Thus when we initialise them from
  * the seed,  we ensure that a bit is set.
  */
 lfsr0= (s->b[0] <<17) | (s->b[1] << 9)| ((s->b[2] & ~7) << 1) | 8 |(s->b[2] & 7);
 lfsr1= (s->b[3] << 9) | 0x100 |s->b[4];

 ++output;

 carry = 0;
 do {
  int bit;
  byte val;

  for (bit = 0, val = 0; bit < 8; ++bit) {
   byte o_lfsr0, o_lfsr1; /* Actually only 1 bit each */
   byte combined;

   o_lfsr0 = ((lfsr0 >> 24) ^ (lfsr0 >> 21) ^ (lfsr0 >> 20) ^ (lfsr0 >> 12)) & 1;
     lfsr0 = (lfsr0 << 1) | o_lfsr0;

   o_lfsr1 = ((lfsr1 >> 16) ^ (lfsr1 >> 2)) & 1;
     lfsr1 = (lfsr1 << 1) | o_lfsr1;

#define  BIT0(x) ((x) & 1)
#define  BIT1(x) (((x) >> 1) & 1)

   combined = !o_lfsr1 + carry + !o_lfsr0;
   carry = BIT1(combined);
   val |= BIT0(combined) << bit;
  }

  *--output = val;
 } while (--len > 0);
}

static byte Secret[];
static byte Varients[];
static byte Table0[];
static byte Table1[];
static byte Table2[];
static byte Table3[];

/*
 * This encryption engine implements one of 32 variations
 * one the same theme depending upon the choice in the
 * varient parameter (0 - 31).
 *
 * The algorithm itself manipulates a 40 bit input into
 * a 40 bit output.
 * The parameter 'input' is 80 bits.  It consists of
 * the 40 bit input value that is to be encrypted followed
 * by a 40 bit seed value for the pseudo random number
 * generators.
 */
static void engine(int varient, byte const *input, struct block *output)
{
 byte cse, term, index;
 struct block temp1;
 struct block temp2;
 byte bits[30];

 int i;

 /* Feed the secret into the input values such that
  * we alter the seed to the LFSR's used above,  then
  * generate the bits to play with.
  */
 for (i = 5; --i > = 0; )
  temp1.b[i] = input[5 + i] ^ Secret[i] ^ Table2[i];

 generate_bits(&bits[29], sizeof bits, &temp1);

 /* This term is used throughout the following to
  * select one of 32 different variations on the
  * algorithm.
  */
 cse = Varients[varient] ^ Table2[varient];

 /* Now the actual blocks doing the encryption.  Each
  * of these works on 40 bits at a time and are quite
  * similar.
  */
 for (i = 5, term = 0; --i > = 0; term = input[i]) {
  index = bits[25 + i] ^ input[i];
  index = Table1[index] ^ ~Table2[index] ^ cse;

  temp1.b[i] = Table2[index] ^ Table3[index] ^ term;
 }
 temp1.b[4] ^= temp1.b[0];

 for (i = 5, term = 0; --i > = 0; term = temp1.b[i]) {
  index = bits[20 + i] ^ temp1.b[i];
  index = Table1[index] ^ ~Table2[index] ^ cse;

  temp2.b[i] = Table2[index] ^ Table3[index] ^ term;
 }
 temp2.b[4] ^= temp2.b[0];

 for (i = 5, term = 0; --i > = 0; term = temp2.b[i]) {
  index = bits[15 + i] ^ temp2.b[i];
  index = Table1[index] ^ ~Table2[index] ^ cse;
  index = Table2[index] ^ Table3[index] ^ term;

  temp1.b[i] = Table0[index] ^ Table2[index];
 }
 temp1.b[4] ^= temp1.b[0];

 for (i = 5, term = 0; --i > = 0; term = temp1.b[i]) {
  index = bits[10 + i] ^ temp1.b[i];
  index = Table1[index] ^ ~Table2[index] ^ cse;

  index = Table2[index] ^ Table3[index] ^ term;

  temp2.b[i] = Table0[index] ^ Table2[index];
 }
 temp2.b[4] ^= temp2.b[0];

 for (i = 5, term = 0; --i > = 0; term = temp2.b[i]) {
  index = bits[5 + i] ^ temp2.b[i];
  index = Table1[index] ^ ~Table2[index] ^ cse;

  temp1.b[i] = Table2[index] ^ Table3[index] ^ term;
 }
 temp1.b[4] ^= temp1.b[0];

 for (i = 5, term = 0; --i > = 0; term = temp1.b[i]) {
  index = bits[i] ^ temp1.b[i];
  index = Table1[index] ^ ~Table2[index] ^ cse;

 output->b[i] = Table2[index] ^ Table3[index] ^ term;
 }
}

static byte Varients[] = {
 0xB7, 0x74, 0x85, 0xD0, 0xCC, 0xDB, 0xCA, 0x73,
 0x03, 0xFE, 0x31, 0x03, 0x52, 0xE0, 0xB7, 0x42,
 0x63, 0x16, 0xF2, 0x2A, 0x79, 0x52, 0xFF, 0x1B,
 0x7A, 0x11, 0xCA, 0x1A, 0x9B, 0x40, 0xAD, 0x01};

static byte Secret[] = {0x55, 0xD6, 0xC4, 0xC5, 0x28};

static byte Table0[] = {
 0xB7, 0xF4, 0x82, 0x57, 0xDA, 0x4D, 0xDB, 0xE2,
 0x2F, 0x52, 0x1A, 0xA8, 0x68, 0x5A, 0x8A, 0xFF,
 0xFB, 0x0E, 0x6D, 0x35, 0xF7, 0x5C, 0x76, 0x12,
 0xCE, 0x25, 0x79, 0x29, 0x39, 0x62, 0x08, 0x24,
 0xA5, 0x85, 0x7B, 0x56, 0x01, 0x23, 0x68, 0xCF,
 0x0A, 0xE2, 0x5A, 0xED, 0x3D, 0x59, 0xB0, 0xA9,
 0xB0, 0x2C, 0xF2, 0xB8, 0xEF, 0x32, 0xA9, 0x40,
 0x80, 0x71, 0xAF, 0x1E, 0xDE, 0x8F, 0x58, 0x88,
 0xB8, 0x3A, 0xD0, 0xFC, 0xC4, 0x1E, 0xB5, 0xA0,
 0xBB, 0x3B, 0x0F, 0x01, 0x7E, 0x1F, 0x9F, 0xD9,
 0xAA, 0xB8, 0x3D, 0x9D, 0x74, 0x1E, 0x25, 0xDB,
 0x37, 0x56, 0x8F, 0x16, 0xBA, 0x49, 0x2B, 0xAC,
 0xD0, 0xBD, 0x95, 0x20, 0xBE, 0x7A, 0x28, 0xD0,
 0x51, 0x64, 0x63, 0x1C, 0x7F, 0x66, 0x10, 0xBB,
 0xC4, 0x56, 0x1A, 0x04, 0x6E, 0x0A, 0xEC, 0x9C,
 0xD6, 0xE8, 0x9A, 0x7A, 0xCF, 0x8C, 0xDB, 0xB1,
 0xEF, 0x71, 0xDE, 0x31, 0xFF, 0x54, 0x3E, 0x5E,
 0x07, 0x69, 0x96, 0xB0, 0xCF, 0xDD, 0x9E, 0x47,
 0xC7, 0x96, 0x8F, 0xE4, 0x2B, 0x59, 0xC6, 0xEE,
 0xB9, 0x86, 0x9A, 0x64, 0x84, 0x72, 0xE2, 0x5B,
 0xA2, 0x96, 0x58, 0x99, 0x50, 0x03, 0xF5, 0x38,
 0x4D, 0x02, 0x7D, 0xE7, 0x7D, 0x75, 0xA7, 0xB8,
 0x67, 0x87, 0x84, 0x3F, 0x1D, 0x11, 0xE5, 0xFC,
 0x1E, 0xD3, 0x83, 0x16, 0xA5, 0x29, 0xF6, 0xC7,
 0x15, 0x61, 0x29, 0x1A, 0x43, 0x4F, 0x9B, 0xAF,
 0xC5, 0x87, 0x34, 0x6C, 0x0F, 0x3B, 0xA8, 0x1D,
 0x45, 0x58, 0x25, 0xDC, 0xA8, 0xA3, 0x3B, 0xD1,
 0x79, 0x1B, 0x48, 0xF2, 0xE9, 0x93, 0x1F, 0xFC,
 0xDB, 0x2A, 0x90, 0xA9, 0x8A, 0x3D, 0x39, 0x18,
 0xA3, 0x8E, 0x58, 0x6C, 0xE0, 0x12, 0xBB, 0x25,
 0xCD, 0x71, 0x22, 0xA2, 0x64, 0xC6, 0xE7, 0xFB,
 0xAD, 0x94, 0x77, 0x04, 0x9A, 0x39, 0xCF, 0x7C};

static byte Table1[] = {
 0x8C, 0x47, 0xB0, 0xE1, 0xEB, 0xFC, 0xEB, 0x56,
 0x10, 0xE5, 0x2C, 0x1A, 0x5D, 0xEF, 0xBE, 0x4F,
 0x08, 0x75, 0x97, 0x4B, 0x0E, 0x25, 0x8E, 0x6E,
 0x39, 0x5A, 0x87, 0x53, 0xC4, 0x1F, 0xF4, 0x5C,
 0x4E, 0xE6, 0x99, 0x30, 0xE0, 0x42, 0x88, 0xAB,
 0xE5, 0x85, 0xBC, 0x8F, 0xD8, 0x3C, 0x54, 0xC9,
 0x53, 0x47, 0x18, 0xD6, 0x06, 0x5B, 0x41, 0x2C,
 0x67, 0x1E, 0x41, 0x74, 0x33, 0xE2, 0xB4, 0xE0,
 0x23, 0x29, 0x42, 0xEA, 0x55, 0x0F, 0x25, 0xB4,
 0x24, 0x2C, 0x99, 0x13, 0xEB, 0x0A, 0x0B, 0xC9,
 0xF9, 0x63, 0x67, 0x43, 0x2D, 0xC7, 0x7D, 0x07,
 0x60, 0x89, 0xD1, 0xCC, 0xE7, 0x94, 0x77, 0x74,
 0x9B, 0x7E, 0xD7, 0xE6, 0xFF, 0xBB, 0x68, 0x14,
 0x1E, 0xA3, 0x25, 0xDE, 0x3A, 0xA3, 0x54, 0x7B,
 0x87, 0x9D, 0x50, 0xCA, 0x27, 0xC3, 0xA4, 0x50,
 0x91, 0x27, 0xD4, 0xB0, 0x82, 0x41, 0x97, 0x79,
 0x94, 0x82, 0xAC, 0xC7, 0x8E, 0xA5, 0x4E, 0xAA,
 0x78, 0x9E, 0xE0, 0x42, 0xBA, 0x28, 0xEA, 0xB7,
 0x74, 0xAD, 0x35, 0xDA, 0x92, 0x60, 0x7E, 0xD2,
 0x0E, 0xB9, 0x24, 0x5E, 0x39, 0x4F, 0x5E, 0x63,
 0x09, 0xB5, 0xFA, 0xBF, 0xF1, 0x22, 0x55, 0x1C,
 0xE2, 0x25, 0xDB, 0xC5, 0xD8, 0x50, 0x03, 0x98,
 0xC4, 0xAC, 0x2E, 0x11, 0xB4, 0x38, 0x4D, 0xD0,
 0xB9, 0xFC, 0x2D, 0x3C, 0x08, 0x04, 0x5A, 0xEF,
 0xCE, 0x32, 0xFB, 0x4C, 0x92, 0x1E, 0x4B, 0xFB,
 0x1A, 0xD0, 0xE2, 0x3E, 0xDA, 0x6E, 0x7C, 0x4D,
 0x56, 0xC3, 0x3F, 0x42, 0xB1, 0x3A, 0x23, 0x4D,
 0x6E, 0x84, 0x56, 0x68, 0xF4, 0x0E, 0x03, 0x64,
 0xD0, 0xA9, 0x92, 0x2F, 0x8B, 0xBC, 0x39, 0x9C,
 0xAC, 0x09, 0x5E, 0xEE, 0xE5, 0x97, 0xBF, 0xA5,
 0xCE, 0xFA, 0x28, 0x2C, 0x6D, 0x4F, 0xEF, 0x77,
 0xAA, 0x1B, 0x79, 0x8E, 0x97, 0xB4, 0xC3, 0xF4};

static byte Table2[] = {
 0xB7, 0x75, 0x81, 0xD5, 0xDC, 0xCA, 0xDE, 0x66,
 0x23, 0xDF, 0x15, 0x26, 0x62, 0xD1, 0x83, 0x77,
 0xE3, 0x97, 0x76, 0xAF, 0xE9, 0xC3, 0x6B, 0x8E,
 0xDA, 0xB0, 0x6E, 0xBF, 0x2B, 0xF1, 0x19, 0xB4,
 0x95, 0x34, 0x48, 0xE4, 0x37, 0x94, 0x5D, 0x7B,
 0x36, 0x5F, 0x65, 0x53, 0x07, 0xE2, 0x89, 0x11,
 0x98, 0x85, 0xD9, 0x12, 0xC1, 0x9D, 0x84, 0xEC,
 0xA4, 0xD4, 0x88, 0xB8, 0xFC, 0x2C, 0x79, 0x28,
 0xD8, 0xDB, 0xB3, 0x1E, 0xA2, 0xF9, 0xD0, 0x44,
 0xD7, 0xD6, 0x60, 0xEF, 0x14, 0xF4, 0xF6, 0x31,
 0xD2, 0x41, 0x46, 0x67, 0x0A, 0xE1, 0x58, 0x27,
 0x43, 0xA3, 0xF8, 0xE0, 0xC8, 0xBA, 0x5A, 0x5C,
 0x80, 0x6C, 0xC6, 0xF2, 0xE8, 0xAD, 0x7D, 0x04,
 0x0D, 0xB9, 0x3C, 0xC2, 0x25, 0xBD, 0x49, 0x63,
 0x8C, 0x9F, 0x51, 0xCE, 0x20, 0xC5, 0xA1, 0x50,
 0x92, 0x2D, 0xDD, 0xBC, 0x8D, 0x4F, 0x9A, 0x71,
 0x2F, 0x30, 0x1D, 0x73, 0x39, 0x13, 0xFB, 0x1A,
 0xCB, 0x24, 0x59, 0xFE, 0x05, 0x96, 0x57, 0x0F,
 0x1F, 0xCF, 0x54, 0xBE, 0xF5, 0x06, 0x1B, 0xB2,
 0x6D, 0xD3, 0x4D, 0x32, 0x56, 0x21, 0x33, 0x0B,
 0x52, 0xE7, 0xAB, 0xEB, 0xA6, 0x74, 0x00, 0x4C,
 0xB1, 0x7F, 0x82, 0x99, 0x87, 0x0E, 0x5E, 0xC0,
 0x8F, 0xEE, 0x6F, 0x55, 0xF3, 0x7E, 0x08, 0x90,
 0xFA, 0xB6, 0x64, 0x70, 0x47, 0x4A, 0x17, 0xA7,
 0xB5, 0x40, 0x8A, 0x38, 0xE5, 0x68, 0x3E, 0x8B,
 0x69, 0xAA, 0x9B, 0x42, 0xA5, 0x10, 0x01, 0x35,
 0xFD, 0x61, 0x9E, 0xE6, 0x16, 0x9C, 0x86, 0xED,
 0xCD, 0x2E, 0xFF, 0xC4, 0x5B, 0xA0, 0xAE, 0xCC,
 0x4B, 0x3B, 0x03, 0xBB, 0x1C, 0x2A, 0xAC, 0x0C,
 0x3F, 0x93, 0xC7, 0x72, 0x7A, 0x09, 0x22, 0x3D,
 0x45, 0x78, 0xA9, 0xA8, 0xEA, 0xC9, 0x6A, 0xF7,
 0x29, 0x91, 0xF0, 0x02, 0x18, 0x3A, 0x4E, 0x7C};

static byte Table3[] = {
 0x73, 0x51, 0x95, 0xE1, 0x12, 0xE4, 0xC0, 0x58,
 0xEE, 0xF2, 0x08, 0x1B, 0xA9, 0xFA, 0x98, 0x4C,
 0xA7, 0x33, 0xE2, 0x1B, 0xA7, 0x6D, 0xF5, 0x30,
 0x97, 0x1D, 0xF3, 0x02, 0x60, 0x5A, 0x82, 0x0F,
 0x91, 0xD0, 0x9C, 0x10, 0x39, 0x7A, 0x83, 0x85,
 0x3B, 0xB2, 0xB8, 0xAE, 0x0C, 0x09, 0x52, 0xEA,
 0x1C, 0xE1, 0x8D, 0x66, 0x4F, 0xF3, 0xDA, 0x92,
 0x29, 0xB9, 0xD5, 0xC5, 0x77, 0x47, 0x22, 0x53,
 0x14, 0xF7, 0xAF, 0x22, 0x64, 0xDF, 0xC6, 0x72,
 0x12, 0xF3, 0x75, 0xDA, 0xD7, 0xD7, 0xE5, 0x02,
 0x9E, 0xED, 0xDA, 0xDB, 0x4C, 0x47, 0xCE, 0x91,
 0x06, 0x06, 0x6D, 0x55, 0x8B, 0x19, 0xC9, 0xEF,
 0x8C, 0x80, 0x1A, 0x0E, 0xEE, 0x4B, 0xAB, 0xF2,
 0x08, 0x5C, 0xE9, 0x37, 0x26, 0x5E, 0x9A, 0x90,
 0x00, 0xF3, 0x0D, 0xB2, 0xA6, 0xA3, 0xF7, 0x26,
 0x17, 0x48, 0x88, 0xC9, 0x0E, 0x2C, 0xC9, 0x02,
 0xE7, 0x18, 0x05, 0x4B, 0xF3, 0x39, 0xE1, 0x20,
 0x02, 0x0D, 0x40, 0xC7, 0xCA, 0xB9, 0x48, 0x30,
 0x57, 0x67, 0xCC, 0x06, 0xBF, 0xAC, 0x81, 0x08,
 0x24, 0x7A, 0xD4, 0x8B, 0x19, 0x8E, 0xAC, 0xB4,
 0x5A, 0x0F, 0x73, 0x13, 0xAC, 0x9E, 0xDA, 0xB6,
 0xB8, 0x96, 0x5B, 0x60, 0x88, 0xE1, 0x81, 0x3F,
 0x07, 0x86, 0x37, 0x2D, 0x79, 0x14, 0x52, 0xEA,
 0x73, 0xDF, 0x3D, 0x09, 0xC8, 0x25, 0x48, 0xD8,
 0x75, 0x60, 0x9A, 0x08, 0x27, 0x4A, 0x2C, 0xB9,
 0xA8, 0x8B, 0x8A, 0x73, 0x62, 0x37, 0x16, 0x02,
 0xBD, 0xC1, 0x0E, 0x56, 0x54, 0x3E, 0x14, 0x5F,
 0x8C, 0x8F, 0x6E, 0x75, 0x1C, 0x07, 0x39, 0x7B,
 0x4B, 0xDB, 0xD3, 0x4B, 0x1E, 0xC8, 0x7E, 0xFE,
 0x3E, 0x72, 0x16, 0x83, 0x7D, 0xEE, 0xF5, 0xCA,
 0xC5, 0x18, 0xF9, 0xD8, 0x68, 0xAB, 0x38, 0x85,
 0xA8, 0xF0, 0xA1, 0x73, 0x9F, 0x5D, 0x19, 0x0B,
 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 0x33, 0x72, 0x39, 0x25, 0x67, 0x26, 0x6D, 0x71,
 0x36, 0x77, 0x3C, 0x20, 0x62, 0x23, 0x68, 0x74,
 0xC3, 0x82, 0xC9, 0x15, 0x57, 0x16, 0x5D, 0x81};

    Oops. Must've been a typo. This is the source code to DeCSS. I guess I'm going to jail now.
 



Kasuto of Kataan

Copyright © 2001 Kasuto.net. All rights reserved.



Site Meter
 Sections Ramblings