From 16247a7506c02836d0e33ba4633f8e02bb5ea81a Mon Sep 17 00:00:00 2001 From: =?utf8?q?St=C3=A9phane=20Borel?= Date: Thu, 15 Feb 2001 21:03:27 +0000 Subject: [PATCH] -New more recent css authentication code. -Beginning of udf support (not in Makefile) --- plugins/dvd/dvd.c | 2 +- plugins/dvd/dvd_css.c | 484 ++++++++++++++++++++++------------------ plugins/dvd/dvd_css.h | 8 +- plugins/dvd/dvd_ifo.c | 13 +- plugins/dvd/dvd_ifo.h | 7 +- plugins/dvd/dvd_udf.c | 198 ++++++++++++++++ plugins/dvd/dvd_udf.h | 25 +++ plugins/dvd/input_dvd.h | 1 + 8 files changed, 515 insertions(+), 223 deletions(-) create mode 100644 plugins/dvd/dvd_udf.c create mode 100644 plugins/dvd/dvd_udf.h diff --git a/plugins/dvd/dvd.c b/plugins/dvd/dvd.c index 80b4edad9f..f648cc4fd7 100644 --- a/plugins/dvd/dvd.c +++ b/plugins/dvd/dvd.c @@ -3,7 +3,7 @@ ***************************************************************************** * Copyright (C) 2000 VideoLAN * - * Authors: + * Authors: Samuel Hocevar * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by diff --git a/plugins/dvd/dvd_css.c b/plugins/dvd/dvd_css.c index 6ea6d3d9d0..683844645d 100644 --- a/plugins/dvd/dvd_css.c +++ b/plugins/dvd/dvd_css.c @@ -2,10 +2,18 @@ * dvd_css.c: Functions for DVD authentification and unscrambling ***************************************************************************** * Copyright (C) 1999-2001 VideoLAN - * $Id: dvd_css.c,v 1.8 2001/02/14 04:11:01 stef Exp $ + * $Id: dvd_css.c,v 1.9 2001/02/15 21:03:27 stef Exp $ * * Author: Stéphane Borel * + * based on: + * - css-auth by Derek Fawcus + * - DVD CSS ioctls example program by Andrew T. Veliath + * - The Divide and conquer attack by Frank A. Stevenson + * - DeCSSPlus by Ethan Hawke + * - DecVOB + * see http://www.lemuria.org/DeCSS/ by Tom Vogt for more information. + * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or @@ -259,151 +267,145 @@ static u8 pi_css_tab5[256]= 0xe0, 0x60, 0xa0, 0x20, 0xc0, 0x40, 0x80, 0x00 }; -/* Mangle tables usesd for key decryption */ -static u8 pi_css_mangle0[256] = -{ - 0x00, 0x81, 0x03, 0x82, 0x06, 0x87, 0x05, 0x84, - 0x0C, 0x8D, 0x0F, 0x8E, 0x0A, 0x8B, 0x09, 0x88, - 0x18, 0x99, 0x1B, 0x9A, 0x1E, 0x9F, 0x1D, 0x9C, - 0x14, 0x95, 0x17, 0x96, 0x12, 0x93, 0x11, 0x90, - 0x30, 0xB1, 0x33, 0xB2, 0x36, 0xB7, 0x35, 0xB4, - 0x3C, 0xBD, 0x3F, 0xBE, 0x3A, 0xBB, 0x39, 0xB8, - 0x28, 0xA9, 0x2B, 0xAA, 0x2E, 0xAF, 0x2D, 0xAC, - 0x24, 0xA5, 0x27, 0xA6, 0x22, 0xA3, 0x21, 0xA0, - 0x60, 0xE1, 0x63, 0xE2, 0x66, 0xE7, 0x65, 0xE4, - 0x6C, 0xED, 0x6F, 0xEE, 0x6A, 0xEB, 0x69, 0xE8, - 0x78, 0xF9, 0x7B, 0xFA, 0x7E, 0xFF, 0x7D, 0xFC, - 0x74, 0xF5, 0x77, 0xF6, 0x72, 0xF3, 0x71, 0xF0, - 0x50, 0xD1, 0x53, 0xD2, 0x56, 0xD7, 0x55, 0xD4, - 0x5C, 0xDD, 0x5F, 0xDE, 0x5A, 0xDB, 0x59, 0xD8, - 0x48, 0xC9, 0x4B, 0xCA, 0x4E, 0xCF, 0x4D, 0xCC, - 0x44, 0xC5, 0x47, 0xC6, 0x42, 0xC3, 0x41, 0xC0, - 0xC0, 0x41, 0xC3, 0x42, 0xC6, 0x47, 0xC5, 0x44, - 0xCC, 0x4D, 0xCF, 0x4E, 0xCA, 0x4B, 0xC9, 0x48, - 0xD8, 0x59, 0xDB, 0x5A, 0xDE, 0x5F, 0xDD, 0x5C, - 0xD4, 0x55, 0xD7, 0x56, 0xD2, 0x53, 0xD1, 0x50, - 0xF0, 0x71, 0xF3, 0x72, 0xF6, 0x77, 0xF5, 0x74, - 0xFC, 0x7D, 0xFF, 0x7E, 0xFA, 0x7B, 0xF9, 0x78, - 0xE8, 0x69, 0xEB, 0x6A, 0xEE, 0x6F, 0xED, 0x6C, - 0xE4, 0x65, 0xE7, 0x66, 0xE2, 0x63, 0xE1, 0x60, - 0xA0, 0x21, 0xA3, 0x22, 0xA6, 0x27, 0xA5, 0x24, - 0xAC, 0x2D, 0xAF, 0x2E, 0xAA, 0x2B, 0xA9, 0x28, - 0xB8, 0x39, 0xBB, 0x3A, 0xBE, 0x3F, 0xBD, 0x3C, - 0xB4, 0x35, 0xB7, 0x36, 0xB2, 0x33, 0xB1, 0x30, - 0x90, 0x11, 0x93, 0x12, 0x96, 0x17, 0x95, 0x14, - 0x9C, 0x1D, 0x9F, 0x1E, 0x9A, 0x1B, 0x99, 0x18, - 0x88, 0x09, 0x8B, 0x0A, 0x8E, 0x0F, 0x8D, 0x0C, - 0x84, 0x05, 0x87, 0x06, 0x82, 0x03, 0x81, 0x00 - }; - -static u8 pi_css_mangle1[256] = -{ - 0xC4, 0xCD, 0xCE, 0xCB, 0xC8, 0xC9, 0xCA, 0xCF, - 0xCC, 0xC5, 0xC6, 0xC3, 0xC0, 0xC1, 0xC2, 0xC7, - 0x14, 0x1D, 0x1E, 0x1B, 0x18, 0x19, 0x1A, 0x1F, - 0x1C, 0x15, 0x16, 0x13, 0x10, 0x11, 0x12, 0x17, - 0x24, 0x2D, 0x2E, 0x2B, 0x28, 0x29, 0x2A, 0x2F, - 0x2C, 0x25, 0x26, 0x23, 0x20, 0x21, 0x22, 0x27, - 0x34, 0x3D, 0x3E, 0x3B, 0x38, 0x39, 0x3A, 0x3F, - 0x3C, 0x35, 0x36, 0x33, 0x30, 0x31, 0x32, 0x37, - 0x04, 0x0D, 0x0E, 0x0B, 0x08, 0x09, 0x0A, 0x0F, - 0x0C, 0x05, 0x06, 0x03, 0x00, 0x01, 0x02, 0x07, - 0xD4, 0xDD, 0xDE, 0xDB, 0xD8, 0xD9, 0xDA, 0xDF, - 0xDC, 0xD5, 0xD6, 0xD3, 0xD0, 0xD1, 0xD2, 0xD7, - 0xE4, 0xED, 0xEE, 0xEB, 0xE8, 0xE9, 0xEA, 0xEF, - 0xEC, 0xE5, 0xE6, 0xE3, 0xE0, 0xE1, 0xE2, 0xE7, - 0xF4, 0xFD, 0xFE, 0xFB, 0xF8, 0xF9, 0xFA, 0xFF, - 0xFC, 0xF5, 0xF6, 0xF3, 0xF0, 0xF1, 0xF2, 0xF7, - 0x44, 0x4D, 0x4E, 0x4B, 0x48, 0x49, 0x4A, 0x4F, - 0x4C, 0x45, 0x46, 0x43, 0x40, 0x41, 0x42, 0x47, - 0x94, 0x9D, 0x9E, 0x9B, 0x98, 0x99, 0x9A, 0x9F, - 0x9C, 0x95, 0x96, 0x93, 0x90, 0x91, 0x92, 0x97, - 0xA4, 0xAD, 0xAE, 0xAB, 0xA8, 0xA9, 0xAA, 0xAF, - 0xAC, 0xA5, 0xA6, 0xA3, 0xA0, 0xA1, 0xA2, 0xA7, - 0xB4, 0xBD, 0xBE, 0xBB, 0xB8, 0xB9, 0xBA, 0xBF, - 0xBC, 0xB5, 0xB6, 0xB3, 0xB0, 0xB1, 0xB2, 0xB7, - 0x84, 0x8D, 0x8E, 0x8B, 0x88, 0x89, 0x8A, 0x8F, - 0x8C, 0x85, 0x86, 0x83, 0x80, 0x81, 0x82, 0x87, - 0x54, 0x5D, 0x5E, 0x5B, 0x58, 0x59, 0x5A, 0x5F, - 0x5C, 0x55, 0x56, 0x53, 0x50, 0x51, 0x52, 0x57, - 0x64, 0x6D, 0x6E, 0x6B, 0x68, 0x69, 0x6A, 0x6F, - 0x6C, 0x65, 0x66, 0x63, 0x60, 0x61, 0x62, 0x67, - 0x74, 0x7D, 0x7E, 0x7B, 0x78, 0x79, 0x7A, 0x7F, - 0x7C, 0x75, 0x76, 0x73, 0x70, 0x71, 0x72, 0x77 -}; - -static u8 pi_css_mangle2[256] = -{ - 0xC4, 0x24, 0x14, 0x34, 0xCE, 0x2E, 0x1E, 0x3E, - 0xCD, 0x2D, 0x1D, 0x3D, 0xCB, 0x2B, 0x1B, 0x3B, - 0x44, 0xA4, 0x94, 0xB4, 0x4E, 0xAE, 0x9E, 0xBE, - 0x4D, 0xAD, 0x9D, 0xBD, 0x4B, 0xAB, 0x9B, 0xBB, - 0x04, 0xE4, 0xD4, 0xF4, 0x0E, 0xEE, 0xDE, 0xFE, - 0x0D, 0xED, 0xDD, 0xFD, 0x0B, 0xEB, 0xDB, 0xFB, - 0x84, 0x64, 0x54, 0x74, 0x8E, 0x6E, 0x5E, 0x7E, - 0x8D, 0x6D, 0x5D, 0x7D, 0x8B, 0x6B, 0x5B, 0x7B, - 0xCC, 0x2C, 0x1C, 0x3C, 0xC6, 0x26, 0x16, 0x36, - 0xC5, 0x25, 0x15, 0x35, 0xC3, 0x23, 0x13, 0x33, - 0x4C, 0xAC, 0x9C, 0xBC, 0x46, 0xA6, 0x96, 0xB6, - 0x45, 0xA5, 0x95, 0xB5, 0x43, 0xA3, 0x93, 0xB3, - 0x0C, 0xEC, 0xDC, 0xFC, 0x06, 0xE6, 0xD6, 0xF6, - 0x05, 0xE5, 0xD5, 0xF5, 0x03, 0xE3, 0xD3, 0xF3, - 0x8C, 0x6C, 0x5C, 0x7C, 0x86, 0x66, 0x56, 0x76, - 0x85, 0x65, 0x55, 0x75, 0x83, 0x63, 0x53, 0x73, - 0xC8, 0x28, 0x18, 0x38, 0xCA, 0x2A, 0x1A, 0x3A, - 0xC9, 0x29, 0x19, 0x39, 0xCF, 0x2F, 0x1F, 0x3F, - 0x48, 0xA8, 0x98, 0xB8, 0x4A, 0xAA, 0x9A, 0xBA, - 0x49, 0xA9, 0x99, 0xB9, 0x4F, 0xAF, 0x9F, 0xBF, - 0x08, 0xE8, 0xD8, 0xF8, 0x0A, 0xEA, 0xDA, 0xFA, - 0x09, 0xE9, 0xD9, 0xF9, 0x0F, 0xEF, 0xDF, 0xFF, - 0x88, 0x68, 0x58, 0x78, 0x8A, 0x6A, 0x5A, 0x7A, - 0x89, 0x69, 0x59, 0x79, 0x8F, 0x6F, 0x5F, 0x7F, - 0xC0, 0x20, 0x10, 0x30, 0xC2, 0x22, 0x12, 0x32, - 0xC1, 0x21, 0x11, 0x31, 0xC7, 0x27, 0x17, 0x37, - 0x40, 0xA0, 0x90, 0xB0, 0x42, 0xA2, 0x92, 0xB2, - 0x41, 0xA1, 0x91, 0xB1, 0x47, 0xA7, 0x97, 0xB7, - 0x00, 0xE0, 0xD0, 0xF0, 0x02, 0xE2, 0xD2, 0xF2, - 0x01, 0xE1, 0xD1, 0xF1, 0x07, 0xE7, 0xD7, 0xF7, - 0x80, 0x60, 0x50, 0x70, 0x82, 0x62, 0x52, 0x72, - 0x81, 0x61, 0x51, 0x71, 0x87, 0x67, 0x57, 0x77 -}; - -static u8 pi_reverse[256] = -{ - 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, - 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, - 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, - 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, - 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, - 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, - 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, - 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, - 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, - 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, - 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, - 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, - 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, - 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, - 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, - 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE, - 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, - 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1, - 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, - 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, - 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, - 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, - 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, - 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, - 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, - 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, - 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, - 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB, - 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, - 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, - 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, - 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF -}; - +static u8 pi_crypt_tab0[256] = { + 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 u8 pi_crypt_tab1[256] = { + 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 u8 pi_crypt_tab2[256] = { + 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 u8 pi_crypt_tab3[288] = { + 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}; /* * Local functions */ @@ -449,9 +451,6 @@ static int CSSGetASF( int i_fd ) static void CSSCryptKey( int i_key_type, int i_varient, u8 const * pi_challenge, u8* pi_key ) { - /* "Secret" key */ - u8 pi_css_secret[5] = { 0xE2, 0xA3, 0x45, 0x10, 0xF4 }; - /* Permutation table for challenge */ u8 ppi_perm_challenge[3][10] = { { 1, 3, 0, 7, 5, 2, 9, 6, 4, 8 }, @@ -469,131 +468,184 @@ static void CSSCryptKey( int i_key_type, int i_varient, 0x13, 0x1b, 0x17, 0x1f, 0x03, 0x0b, 0x07, 0x0f, 0x11, 0x19, 0x15, 0x1d, 0x01, 0x09, 0x05, 0x0d } }; - /* CSS varient for mangling */ - u8 pi_css_varients[32] = - { 0x00, 0x01, 0x04, 0x05, 0x10, 0x11, 0x14, 0x15, - 0x20, 0x21, 0x24, 0x25, 0x30, 0x31, 0x34, 0x35, - 0x80, 0x81, 0x84, 0x85, 0x90, 0x91, 0x94, 0x95, - 0xA0, 0xA1, 0xA4, 0xA5, 0xB0, 0xB1, 0xB4, 0xB5 }; + u8 pi_varients[32] = + { 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 }; + + /* The "secret" key */ + u8 pi_secret[5] = { 0x55, 0xD6, 0xC4, 0xC5, 0x28 }; + u8 pi_bits[30]; u8 pi_scratch[10]; u8 pi_tmp1[5]; u8 pi_tmp2[5]; - u8 i_lfsr0_o; - u8 i_lfsr1_o; + u8 i_lfsr0_o; /* 1 bit used */ + u8 i_lfsr1_o; /* 1 bit used */ u32 i_lfsr0; u32 i_lfsr1; u8 i_css_varient; - int i_val = 0; + u8 i_cse; + u8 i_index; + u8 i_combined; + u8 i_carry; + u8 i_val = 0; int i_term = 0; - int i, i_index; + int i_bit; + int i; - for( i=0 ; i<10 ; i++ ) - { + for (i = 9; i >= 0; --i) pi_scratch[i] = pi_challenge[ppi_perm_challenge[i_key_type][i]]; - } - i_css_varient = i_key_type == 0 ? i_varient - : ppi_perm_varient[i_key_type-1][i_varient]; - for( i=0 ; i<5 ; i++ ) + i_css_varient = ( i_key_type == 0 ) ? i_varient : + ppi_perm_varient[i_key_type-1][i_varient]; + + /* + * 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. + */ + + /* 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 ; ) { - pi_tmp1[i] = pi_scratch[5+i] ^ pi_css_secret[i]; + pi_tmp1[i] = pi_scratch[5 + i] ^ pi_secret[i] ^ pi_crypt_tab2[i]; } + /* + * 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. + * + */ + /* 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. */ i_lfsr0 = ( pi_tmp1[0] << 17 ) | ( pi_tmp1[1] << 9 ) | - ( ( pi_tmp1[2] & ~7 ) << 1 ) | 8 | (pi_tmp1[2] & 7); - - - /* - * reverse lfsr0/1 to simplify calculation in loop - */ - i_lfsr0 = ( pi_reverse[i_lfsr0 & 0xff] << 17 ) | - ( pi_reverse[( i_lfsr0 >> 8 ) & 0xff] << 9 ) | - ( pi_reverse[( i_lfsr0 >> 16 ) & 0xff] << 1) | - ( i_lfsr0 >> 24 ); - - i_lfsr1 = ( pi_reverse[pi_tmp1[4]] << 9 ) | 0x100 | - ( pi_reverse[pi_tmp1[3]] ); + (( pi_tmp1[2] & ~7 ) << 1 ) | 8 | ( pi_tmp1[2] & 7 ); + i_lfsr1 = ( pi_tmp1[3] << 9 ) | 0x100 | pi_tmp1[4]; - i_index = sizeof( pi_bits ); + i_index = sizeof(pi_bits); + i_carry = 0; do { - i_lfsr0_o = ( i_lfsr0 >> 12) ^ ( i_lfsr0 >> 4) ^ - ( i_lfsr0 >> 3) ^ i_lfsr0; - - i_lfsr1_o = ( ( i_lfsr1 >> 14 ) & 7) ^ i_lfsr1; - i_lfsr1_o ^= ( i_lfsr1_o << 3 ) ^ ( i_lfsr1_o << 6 ); - - i_lfsr1 = ( i_lfsr1 >> 8) ^ ( i_lfsr1_o << 9); - i_lfsr0 = ( i_lfsr0 >> 8 ) ^ ( i_lfsr0_o << 17); + for( i_bit = 0, i_val = 0 ; i_bit < 8 ; ++i_bit ) + { - i_lfsr0_o = ~i_lfsr0_o; - i_lfsr1_o = ~i_lfsr1_o; + i_lfsr0_o = ( ( i_lfsr0 >> 24 ) ^ ( i_lfsr0 >> 21 ) ^ + ( i_lfsr0 >> 20 ) ^ ( i_lfsr0 >> 12 ) ) & 1; + i_lfsr0 = ( i_lfsr0 << 1 ) | i_lfsr0_o; - i_val += i_lfsr0_o + i_lfsr1_o; + i_lfsr1_o = ( ( i_lfsr1 >> 16 ) ^ ( i_lfsr1 >> 2 ) ) & 1; + i_lfsr1 = ( i_lfsr1 << 1 ) | i_lfsr1_o; - pi_bits[--i_index] = i_val & 0xFF; - i_val >>= 8; +#define BIT0(x) ((x) & 1) +#define BIT1(x) (((x) >> 1) & 1) + i_combined = !i_lfsr1_o + i_carry + !i_lfsr0_o; + /* taking bit 1 */ + i_carry = ( i_combined >> 1 ) & 1; + i_val |= ( i_combined & 1 ) << i_bit; + } + + pi_bits[--i_index] = i_val; } while( i_index > 0 ); - i_css_varient = pi_css_varients[i_css_varient]; + /* This term is used throughout the following to + * select one of 32 different variations on the + * algorithm. + */ + i_cse = pi_varients[i_css_varient] ^ pi_crypt_tab2[i_css_varient]; - /* - * Mangling + /* Now the actual blocks doing the encryption. Each + * of these works on 40 bits at a time and are quite + * similar. */ + i_index = 0; for( i = 5, i_term = 0 ; --i >= 0 ; i_term = pi_scratch[i] ) { - i_index = pi_bits[25+i] ^ pi_scratch[i]; - i_index = pi_css_mangle1[i_index] ^ i_css_varient; - pi_tmp1[i] = pi_css_mangle2[i_index] ^ i_term; + i_index = pi_bits[25 + i] ^ pi_scratch[i]; + i_index = pi_crypt_tab1[i_index] ^ ~pi_crypt_tab2[i_index] ^ i_cse; + + pi_tmp1[i] = pi_crypt_tab2[i_index] ^ pi_crypt_tab3[i_index] ^ i_term; } pi_tmp1[4] ^= pi_tmp1[0]; for( i = 5, i_term = 0 ; --i >= 0 ; i_term = pi_tmp1[i] ) { - i_index = pi_bits[20+i] ^ pi_tmp1[i]; - i_index = pi_css_mangle1[i_index] ^ i_css_varient; - pi_tmp2[i] = pi_css_mangle2[i_index] ^ i_term; + i_index = pi_bits[20 + i] ^ pi_tmp1[i]; + i_index = pi_crypt_tab1[i_index] ^ ~pi_crypt_tab2[i_index] ^ i_cse; + + pi_tmp2[i] = pi_crypt_tab2[i_index] ^ pi_crypt_tab3[i_index] ^ i_term; } pi_tmp2[4] ^= pi_tmp2[0]; for( i = 5, i_term = 0 ; --i >= 0 ; i_term = pi_tmp2[i] ) { - i_index = pi_bits[15+i] ^ pi_tmp2[i]; - i_index = pi_css_mangle1[i_index] ^ i_css_varient; - i_index = pi_css_mangle2[i_index] ^ i_term; - pi_tmp1[i] = pi_css_mangle0[i_index]; + i_index = pi_bits[15 + i] ^ pi_tmp2[i]; + i_index = pi_crypt_tab1[i_index] ^ ~pi_crypt_tab2[i_index] ^ i_cse; + i_index = pi_crypt_tab2[i_index] ^ pi_crypt_tab3[i_index] ^ i_term; + + pi_tmp1[i] = pi_crypt_tab0[i_index] ^ pi_crypt_tab2[i_index]; } pi_tmp1[4] ^= pi_tmp1[0]; for( i = 5, i_term = 0 ; --i >= 0 ; i_term = pi_tmp1[i] ) { - i_index = pi_bits[10+i] ^ pi_tmp1[i]; - i_index = pi_css_mangle1[i_index] ^ i_css_varient; - i_index = pi_css_mangle2[i_index] ^ i_term; - pi_tmp2[i] = pi_css_mangle0[i_index]; + i_index = pi_bits[10 + i] ^ pi_tmp1[i]; + i_index = pi_crypt_tab1[i_index] ^ ~pi_crypt_tab2[i_index] ^ i_cse; + + i_index = pi_crypt_tab2[i_index] ^ pi_crypt_tab3[i_index] ^ i_term; + + pi_tmp2[i] = pi_crypt_tab0[i_index] ^ pi_crypt_tab2[i_index]; } pi_tmp2[4] ^= pi_tmp2[0]; for( i = 5, i_term = 0 ; --i >= 0 ; i_term = pi_tmp2[i] ) { - i_index = pi_bits[5+i] ^ pi_tmp2[i]; - i_index = pi_css_mangle1[i_index] ^ i_css_varient; - pi_tmp1[i] = pi_css_mangle2[i_index] ^ i_term; + i_index = pi_bits[5 + i] ^ pi_tmp2[i]; + i_index = pi_crypt_tab1[i_index] ^ ~pi_crypt_tab2[i_index] ^ i_cse; + + pi_tmp1[i] = pi_crypt_tab2[i_index] ^ pi_crypt_tab3[i_index] ^ i_term; } pi_tmp1[4] ^= pi_tmp1[0]; - for( i=5, i_term=0 ; --i>=0 ; i_term=pi_tmp1[i] ) + for(i = 5, i_term = 0 ; --i >= 0 ; i_term = pi_tmp1[i] ) { i_index = pi_bits[i] ^ pi_tmp1[i]; - i_index = pi_css_mangle1[i_index] ^ i_css_varient; - pi_key[i] = pi_css_mangle2[i_index] ^ i_term; + i_index = pi_crypt_tab1[i_index] ^ ~pi_crypt_tab2[i_index] ^ i_cse; + + pi_key[i] = pi_crypt_tab2[i_index] ^ pi_crypt_tab3[i_index] ^ i_term; } return; diff --git a/plugins/dvd/dvd_css.h b/plugins/dvd/dvd_css.h index a9fb4891f6..35f6f40377 100644 --- a/plugins/dvd/dvd_css.h +++ b/plugins/dvd/dvd_css.h @@ -2,10 +2,16 @@ * dvd_css.h: Structures for DVD authentification and unscrambling ***************************************************************************** * Copyright (C) 1999-2001 VideoLAN - * $Id: dvd_css.h,v 1.2 2001/02/13 10:08:51 stef Exp $ + * $Id: dvd_css.h,v 1.3 2001/02/15 21:03:27 stef Exp $ * * Author: Stéphane Borel * + * based on: + * - css-auth by Derek Fawcus + * - DVD CSS ioctls example program by Andrew T. Veliath + * - DeCSSPlus by Ethan Hawke + * - The Divide and conquer attack by Frank A. Stevenson + * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or diff --git a/plugins/dvd/dvd_ifo.c b/plugins/dvd/dvd_ifo.c index 70f2820e46..a19970bb2c 100644 --- a/plugins/dvd/dvd_ifo.c +++ b/plugins/dvd/dvd_ifo.c @@ -2,10 +2,15 @@ * dvd_ifo.c: Functions for ifo parsing ***************************************************************************** * Copyright (C) 1999-2001 VideoLAN - * $Id: dvd_ifo.c,v 1.7 2001/02/14 04:11:01 stef Exp $ + * $Id: dvd_ifo.c,v 1.8 2001/02/15 21:03:27 stef Exp $ * * Author: Stéphane Borel * + * based on: + * - libifo by Thomas Mirlacher + * - IFO structure documentation by Thomas Mirlacher, Björn Englund, + * Håkan Hjort + * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or @@ -62,7 +67,7 @@ static int IfoFindVMG( ifo_t* p_ifo ) } p_ifo->i_off = p_ifo->i_pos; -//fprintf( stderr, "VMG Off : %lld\n", (long long)(p_ifo->i_off) ); +fprintf( stderr, "VMG Off : %lld\n", (long long)(p_ifo->i_off) ); return 0; } @@ -87,7 +92,7 @@ static int IfoFindVTS( ifo_t* p_ifo ) } p_ifo->i_off = p_ifo->i_pos; -//fprintf( stderr, "VTS Off : %lld\n", (long long)(p_ifo->i_off) ); +fprintf( stderr, "VTS Off : %lld\n", (long long)(p_ifo->i_off) ); return 0; } @@ -1115,7 +1120,7 @@ void IfoRead( ifo_t* p_ifo ) i_off = (off_t)(p_ifo->vmg.ptt_srpt.p_tts[i].i_ssector) *DVD_LB_SIZE; p_ifo->i_pos = lseek( p_ifo->i_fd, i_off, SEEK_SET ); -//fprintf( stderr, "%lld\n" , p_ifo->i_pos ); +fprintf( stderr, "%lld\n" , p_ifo->i_pos ); /* FIXME : use udf filesystem to avoid this */ IfoFindVTS( p_ifo ); diff --git a/plugins/dvd/dvd_ifo.h b/plugins/dvd/dvd_ifo.h index fc2554ad79..cb975850b9 100644 --- a/plugins/dvd/dvd_ifo.h +++ b/plugins/dvd/dvd_ifo.h @@ -2,10 +2,15 @@ * dvd_ifo.h: Structures for ifo parsing ***************************************************************************** * Copyright (C) 1999-2001 VideoLAN - * $Id: dvd_ifo.h,v 1.5 2001/02/14 04:11:01 stef Exp $ + * $Id: dvd_ifo.h,v 1.6 2001/02/15 21:03:27 stef Exp $ * * Author: Stéphane Borel * + * based on: + * - libifo by Thomas Mirlacher + * - IFO structure documentation by Thomas Mirlacher, Björn Englund, + * Håkan Hjort + * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or diff --git a/plugins/dvd/dvd_udf.c b/plugins/dvd/dvd_udf.c new file mode 100644 index 0000000000..136ff63677 --- /dev/null +++ b/plugins/dvd/dvd_udf.c @@ -0,0 +1,198 @@ +/***************************************************************************** + * dvd_udf.c: udf filesystem tools. + * --- + * Mainly used to find asolute logical block adress of *.ifo files + ***************************************************************************** + * Copyright (C) 1998-2001 VideoLAN + * $Id: dvd_udf.c,v 1.1 2001/02/15 21:03:27 stef Exp $ + * + * Author: Stéphane Borel + * + * based on: + * - dvdudf by Christian Wolff + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + *****************************************************************************/ +/* + * Preamble + */ +#include "defs.h" + +#include +#include +#include +#include +#include + +#include "common.h" +#include "intf_msg.h" +#include "input_dvd.h" + +/* + * Local structures + */ +typedef struct partition_s +{ + int i_valid; + u8 pi_volume_desc[128]; + u16 i_flags; + u16 i_number; + u8 pi_contents[32]; + u32 i_accessType; + u32 i_start; + u32 i_length; +} partition_t; + +typedef struct ad_s +{ + u32 i_location; + u32 i_length; + u8 i_flags; + u16 i_partition; +} ad_t; + +/* + * Local functions + */ + +/***************************************************************************** + * UDFDecode: decode udf data that is unicode encoded + *****************************************************************************/ +static int UDFDecode( u8 * pi_data, int i_len, char * psz_target ) +{ + int p = 1; + int i = 0; + + if( !( pi_data[0] & 0x18 ) ) + { + psz_target[0] ='\0'; + return 0; + } + + if( data[0] & 0x10 ) + { + /* ignore MSB of unicode16 */ + p++; + + while( p < i_len ) + { + psz_target[i++] = pi_data[p+=2]; + } + } + else + { + while( p < i_len ) + { + psz_target[i++] = pi_data[p++]; + } + } + + psz_target[i]='\0'; + + return 0; +} + +/***************************************************************************** + * UDFInit: some check and initialization in udf filesystem + *****************************************************************************/ +int UDFInit( u8 * pi_data, udf_t * p_udf ) +{ + u32i lbsize,MT_L,N_PM; + + UDFDecode( &pi_data[84], 128, p_udf->psz_volume_desc ); + lbsize = GETN4(212); // should be 2048 + MT_L = GETN4(264); // should be 6 + N_PM = GETN4(268); // should be 1 + + if( lbsize != DVD_LB_SIZE ) + { + return 1; + } + + return 0; +} + +/***************************************************************************** + * UDFFileEntry: + *****************************************************************************/ +int UDFFileEntry (uint8_t *data, uint8_t *FileType, struct AD *ad) +{ + uint8_t filetype; + uint16_t flags; + uint32_t L_EA,L_AD; + int p; + + UDFICB(&data[16],&filetype,&flags); + FileType[0]=filetype; + L_EA=GETN4(168); + L_AD=GETN4(172); + p=176+L_EA; + + while (p<176+L_EA+L_AD) { + switch (flags&0x07) { + case 0: + UDFAD (&data[p], ad, UDFADshort); + p += 0x08; + break; + case 1: + UDFAD (&data[p], ad, UDFADlong); + p += 0x10; + break; + case 2: UDFAD (&data[p], ad, UDFADext); + p += 0x14; + break; + case 3: + switch (L_AD) { + case 0x08: + UDFAD (&data[p], ad, UDFADshort); + break; + case 0x10: + UDFAD (&data[p], ad, UDFADlong); + break; + case 0x14: + UDFAD (&data[p], ad, UDFADext); + break; + } + default: + p += L_AD; + break; + } + } + + return 0; +} + +/***************************************************************************** + * UDFFileIdentifier: + *****************************************************************************/ +int UDFFileIdentifier (uint8_t *data, uint8_t *FileCharacteristics, char *FileName, struct AD *FileICB) +{ + uint8_t L_FI; + uint16_t L_IU; + + FileCharacteristics[0]=GETN1(18); + L_FI=GETN1(19); + UDFAD(&data[20],FileICB,UDFADlong); + L_IU=GETN2(36); + + if (L_FI) + _Unicodedecode (&data[38+L_IU],L_FI,FileName); + else + FileName[0]='\0'; + + return 4*((38+L_FI+L_IU+3)/4); +} + + diff --git a/plugins/dvd/dvd_udf.h b/plugins/dvd/dvd_udf.h new file mode 100644 index 0000000000..037d2e5dcc --- /dev/null +++ b/plugins/dvd/dvd_udf.h @@ -0,0 +1,25 @@ +/***************************************************************************** + * dvd_udf.h: structures for udf filesystem tools. + ***************************************************************************** + * Copyright (C) 1998-2001 VideoLAN + * $Id: dvd_udf.h,v 1.1 2001/02/15 21:03:27 stef Exp $ + * + * Author: Stéphane Borel + * + * based on: + * - dvdudf by Christian Wolff + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + *****************************************************************************/ diff --git a/plugins/dvd/input_dvd.h b/plugins/dvd/input_dvd.h index 88faac3832..11c5b1823f 100644 --- a/plugins/dvd/input_dvd.h +++ b/plugins/dvd/input_dvd.h @@ -23,6 +23,7 @@ /***************************************************************************** * Preamble *****************************************************************************/ +/* Logical block size for DVD-VIDEO */ #define DVD_LB_SIZE 2048 /***************************************************************************** -- 2.39.5