X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=plugins%2Fdvd%2Fdvd_css.c;h=ab73262471a407d0712d80479ed3b4a5e24bfb47;hb=94d3d4d8be146d5a7ca5e77eb025820d26b9396d;hp=9da6cd87d6b30b7ad7c4d069a9e3baf180cabc9c;hpb=17a54d55f3f5b989f217c5377ae85f97eda76e29;p=vlc diff --git a/plugins/dvd/dvd_css.c b/plugins/dvd/dvd_css.c index 9da6cd87d6..ab73262471 100644 --- a/plugins/dvd/dvd_css.c +++ b/plugins/dvd/dvd_css.c @@ -2,14 +2,14 @@ * dvd_css.c: Functions for DVD authentification and unscrambling ***************************************************************************** * Copyright (C) 1999-2001 VideoLAN - * $Id: dvd_css.c,v 1.15 2001/02/22 08:44:45 stef Exp $ + * $Id: dvd_css.c,v 1.30 2001/05/31 01:37:08 sam 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 + * - 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. @@ -35,1223 +35,782 @@ #include "defs.h" #include +#include + +#ifdef HAVE_UNISTD_H #include -#include -#include -#include -#ifdef HAVE_SYS_IOCTL_H -# include -#endif -#ifdef HAVE_SYS_DVDIO_H -# include -#endif -#ifdef LINUX_DVD -# include +#elif defined( _MSC_VER ) && defined( _WIN32 ) +#include #endif +#include + #include "common.h" #include "intf_msg.h" #include "dvd_css.h" +#ifdef HAVE_CSS +#include "dvd_csstables.h" +#endif /* HAVE_CSS */ #include "dvd_ioctl.h" -#include "dvd_ifo.h" #include "input_dvd.h" /***************************************************************************** - * CSS tables + * Local prototypes *****************************************************************************/ -static u8 pi_css_tab1[256]= -{ 0x33, 0x73, 0x3b, 0x26, 0x63, 0x23, 0x6b, 0x76, - 0x3e, 0x7e, 0x36, 0x2b, 0x6e, 0x2e, 0x66, 0x7b, - 0xd3, 0x93, 0xdb, 0x06, 0x43, 0x03, 0x4b, 0x96, - 0xde, 0x9e, 0xd6, 0x0b, 0x4e, 0x0e, 0x46, 0x9b, - 0x57, 0x17, 0x5f, 0x82, 0xc7, 0x87, 0xcf, 0x12, - 0x5a, 0x1a, 0x52, 0x8f, 0xca, 0x8a, 0xc2, 0x1f, - 0xd9, 0x99, 0xd1, 0x00, 0x49, 0x09, 0x41, 0x90, - 0xd8, 0x98, 0xd0, 0x01, 0x48, 0x08, 0x40, 0x91, - 0x3d, 0x7d, 0x35, 0x24, 0x6d, 0x2d, 0x65, 0x74, - 0x3c, 0x7c, 0x34, 0x25, 0x6c, 0x2c, 0x64, 0x75, - 0xdd, 0x9d, 0xd5, 0x04, 0x4d, 0x0d, 0x45, 0x94, - 0xdc, 0x9c, 0xd4, 0x05, 0x4c, 0x0c, 0x44, 0x95, - 0x59, 0x19, 0x51, 0x80, 0xc9, 0x89, 0xc1, 0x10, - 0x58, 0x18, 0x50, 0x81, 0xc8, 0x88, 0xc0, 0x11, - 0xd7, 0x97, 0xdf, 0x02, 0x47, 0x07, 0x4f, 0x92, - 0xda, 0x9a, 0xd2, 0x0f, 0x4a, 0x0a, 0x42, 0x9f, - 0x53, 0x13, 0x5b, 0x86, 0xc3, 0x83, 0xcb, 0x16, - 0x5e, 0x1e, 0x56, 0x8b, 0xce, 0x8e, 0xc6, 0x1b, - 0xb3, 0xf3, 0xbb, 0xa6, 0xe3, 0xa3, 0xeb, 0xf6, - 0xbe, 0xfe, 0xb6, 0xab, 0xee, 0xae, 0xe6, 0xfb, - 0x37, 0x77, 0x3f, 0x22, 0x67, 0x27, 0x6f, 0x72, - 0x3a, 0x7a, 0x32, 0x2f, 0x6a, 0x2a, 0x62, 0x7f, - 0xb9, 0xf9, 0xb1, 0xa0, 0xe9, 0xa9, 0xe1, 0xf0, - 0xb8, 0xf8, 0xb0, 0xa1, 0xe8, 0xa8, 0xe0, 0xf1, - 0x5d, 0x1d, 0x55, 0x84, 0xcd, 0x8d, 0xc5, 0x14, - 0x5c, 0x1c, 0x54, 0x85, 0xcc, 0x8c, 0xc4, 0x15, - 0xbd, 0xfd, 0xb5, 0xa4, 0xed, 0xad, 0xe5, 0xf4, - 0xbc, 0xfc, 0xb4, 0xa5, 0xec, 0xac, 0xe4, 0xf5, - 0x39, 0x79, 0x31, 0x20, 0x69, 0x29, 0x61, 0x70, - 0x38, 0x78, 0x30, 0x21, 0x68, 0x28, 0x60, 0x71, - 0xb7, 0xf7, 0xbf, 0xa2, 0xe7, 0xa7, 0xef, 0xf2, - 0xba, 0xfa, 0xb2, 0xaf, 0xea, 0xaa, 0xe2, 0xff -}; - -static u8 pi_css_tab2[256]= -{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, - 0x09, 0x08, 0x0b, 0x0a, 0x0d, 0x0c, 0x0f, 0x0e, - 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15, - 0x1b, 0x1a, 0x19, 0x18, 0x1f, 0x1e, 0x1d, 0x1c, - 0x24, 0x25, 0x26, 0x27, 0x20, 0x21, 0x22, 0x23, - 0x2d, 0x2c, 0x2f, 0x2e, 0x29, 0x28, 0x2b, 0x2a, - 0x36, 0x37, 0x34, 0x35, 0x32, 0x33, 0x30, 0x31, - 0x3f, 0x3e, 0x3d, 0x3c, 0x3b, 0x3a, 0x39, 0x38, - 0x49, 0x48, 0x4b, 0x4a, 0x4d, 0x4c, 0x4f, 0x4e, - 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, - 0x5b, 0x5a, 0x59, 0x58, 0x5f, 0x5e, 0x5d, 0x5c, - 0x52, 0x53, 0x50, 0x51, 0x56, 0x57, 0x54, 0x55, - 0x6d, 0x6c, 0x6f, 0x6e, 0x69, 0x68, 0x6b, 0x6a, - 0x64, 0x65, 0x66, 0x67, 0x60, 0x61, 0x62, 0x63, - 0x7f, 0x7e, 0x7d, 0x7c, 0x7b, 0x7a, 0x79, 0x78, - 0x76, 0x77, 0x74, 0x75, 0x72, 0x73, 0x70, 0x71, - 0x92, 0x93, 0x90, 0x91, 0x96, 0x97, 0x94, 0x95, - 0x9b, 0x9a, 0x99, 0x98, 0x9f, 0x9e, 0x9d, 0x9c, - 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, - 0x89, 0x88, 0x8b, 0x8a, 0x8d, 0x8c, 0x8f, 0x8e, - 0xb6, 0xb7, 0xb4, 0xb5, 0xb2, 0xb3, 0xb0, 0xb1, - 0xbf, 0xbe, 0xbd, 0xbc, 0xbb, 0xba, 0xb9, 0xb8, - 0xa4, 0xa5, 0xa6, 0xa7, 0xa0, 0xa1, 0xa2, 0xa3, - 0xad, 0xac, 0xaf, 0xae, 0xa9, 0xa8, 0xab, 0xaa, - 0xdb, 0xda, 0xd9, 0xd8, 0xdf, 0xde, 0xdd, 0xdc, - 0xd2, 0xd3, 0xd0, 0xd1, 0xd6, 0xd7, 0xd4, 0xd5, - 0xc9, 0xc8, 0xcb, 0xca, 0xcd, 0xcc, 0xcf, 0xce, - 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, - 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, - 0xf6, 0xf7, 0xf4, 0xf5, 0xf2, 0xf3, 0xf0, 0xf1, - 0xed, 0xec, 0xef, 0xee, 0xe9, 0xe8, 0xeb, 0xea, - 0xe4, 0xe5, 0xe6, 0xe7, 0xe0, 0xe1, 0xe2, 0xe3 -}; - -static u8 pi_css_tab3[512]= -{ 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff, - 0x00, 0x24, 0x49, 0x6d, 0x92, 0xb6, 0xdb, 0xff -}; - -static u8 pi_css_tab4[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_css_tab5[256]= -{ 0xff, 0x7f, 0xbf, 0x3f, 0xdf, 0x5f, 0x9f, 0x1f, - 0xef, 0x6f, 0xaf, 0x2f, 0xcf, 0x4f, 0x8f, 0x0f, - 0xf7, 0x77, 0xb7, 0x37, 0xd7, 0x57, 0x97, 0x17, - 0xe7, 0x67, 0xa7, 0x27, 0xc7, 0x47, 0x87, 0x07, - 0xfb, 0x7b, 0xbb, 0x3b, 0xdb, 0x5b, 0x9b, 0x1b, - 0xeb, 0x6b, 0xab, 0x2b, 0xcb, 0x4b, 0x8b, 0x0b, - 0xf3, 0x73, 0xb3, 0x33, 0xd3, 0x53, 0x93, 0x13, - 0xe3, 0x63, 0xa3, 0x23, 0xc3, 0x43, 0x83, 0x03, - 0xfd, 0x7d, 0xbd, 0x3d, 0xdd, 0x5d, 0x9d, 0x1d, - 0xed, 0x6d, 0xad, 0x2d, 0xcd, 0x4d, 0x8d, 0x0d, - 0xf5, 0x75, 0xb5, 0x35, 0xd5, 0x55, 0x95, 0x15, - 0xe5, 0x65, 0xa5, 0x25, 0xc5, 0x45, 0x85, 0x05, - 0xf9, 0x79, 0xb9, 0x39, 0xd9, 0x59, 0x99, 0x19, - 0xe9, 0x69, 0xa9, 0x29, 0xc9, 0x49, 0x89, 0x09, - 0xf1, 0x71, 0xb1, 0x31, 0xd1, 0x51, 0x91, 0x11, - 0xe1, 0x61, 0xa1, 0x21, 0xc1, 0x41, 0x81, 0x01, - 0xfe, 0x7e, 0xbe, 0x3e, 0xde, 0x5e, 0x9e, 0x1e, - 0xee, 0x6e, 0xae, 0x2e, 0xce, 0x4e, 0x8e, 0x0e, - 0xf6, 0x76, 0xb6, 0x36, 0xd6, 0x56, 0x96, 0x16, - 0xe6, 0x66, 0xa6, 0x26, 0xc6, 0x46, 0x86, 0x06, - 0xfa, 0x7a, 0xba, 0x3a, 0xda, 0x5a, 0x9a, 0x1a, - 0xea, 0x6a, 0xaa, 0x2a, 0xca, 0x4a, 0x8a, 0x0a, - 0xf2, 0x72, 0xb2, 0x32, 0xd2, 0x52, 0x92, 0x12, - 0xe2, 0x62, 0xa2, 0x22, 0xc2, 0x42, 0x82, 0x02, - 0xfc, 0x7c, 0xbc, 0x3c, 0xdc, 0x5c, 0x9c, 0x1c, - 0xec, 0x6c, 0xac, 0x2c, 0xcc, 0x4c, 0x8c, 0x0c, - 0xf4, 0x74, 0xb4, 0x34, 0xd4, 0x54, 0x94, 0x14, - 0xe4, 0x64, 0xa4, 0x24, 0xc4, 0x44, 0x84, 0x04, - 0xf8, 0x78, 0xb8, 0x38, 0xd8, 0x58, 0x98, 0x18, - 0xe8, 0x68, 0xa8, 0x28, 0xc8, 0x48, 0x88, 0x08, - 0xf0, 0x70, 0xb0, 0x30, 0xd0, 0x50, 0x90, 0x10, - 0xe0, 0x60, 0xa0, 0x20, 0xc0, 0x40, 0x80, 0x00 -}; - -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 - */ +#ifdef HAVE_CSS +static int CSSGetASF ( int i_fd ); +static void CSSCryptKey ( int i_key_type, int i_varient, + u8 const * pi_challenge, u8* pi_key ); +static int CSSCracker ( int i_start, unsigned char * p_crypted, + unsigned char * p_decrypted, + dvd_key_t * p_sector_key, dvd_key_t * p_key ); +#endif /* HAVE_CSS */ /***************************************************************************** - * CSSGetASF : Get Authentification success flag - * --- - * Returns : - * -1 on ioctl error, - * 0 if the device needs to be authenticated, - * 1 either. + * CSSTest : check if the disc is encrypted or not *****************************************************************************/ -static int CSSGetASF( int i_fd ) +int CSSTest( int i_fd ) { - dvd_authinfo auth_info; + int i_ret, i_copyright; - auth_info.type = DVD_LU_SEND_ASF; - auth_info.lsasf.asf = 0; + i_ret = ioctl_ReadCopyright( i_fd, 0 /* i_layer */, &i_copyright ); - for( auth_info.lsasf.agid = 0 ; auth_info.lsasf.agid < 4 ; - auth_info.lsasf.agid++ ) + if( i_ret < 0 ) { - if( !( dvd_ioctl( i_fd, DVD_AUTH, &auth_info ) ) ) - { - intf_WarnMsg( 3, "CSS: %sAuthenticated", - ( auth_info.lsasf.asf ) ? "" : "not " ); - return auth_info.lsasf.asf; - } + /* Since it's the first ioctl we try to issue, we add a notice */ + intf_ErrMsg( "css error: ioctl_ReadCopyright failed, " + "make sure DVD ioctls were compiled in" ); + + return i_ret; } - /* The ioctl process has failed */ - intf_ErrMsg( "CSS: GetASF Fatal Error" ); - return -1; + return i_copyright; } /***************************************************************************** - * CSSCryptKey : shuffles bits and unencrypt keys. - * Used during authentication and disc key negociation in CSSInit. - * --- - * i_key_type : 0->key1, 1->key2, 2->buskey. - * i_varient : between 0 and 31. + * CSSInit : CSS Structure initialisation and DVD authentication. + ***************************************************************************** + * It simulates the mutual authentication between logical unit and host. + * Since we don't need the disc key to find the title key, we just run the + * basic unavoidable commands to authenticate device and disc. *****************************************************************************/ -static void CSSCryptKey( int i_key_type, int i_varient, - u8 const * pi_challenge, u8* pi_key ) +int CSSInit( int i_fd, css_t * p_css ) { - /* Permutation table for challenge */ - u8 ppi_perm_challenge[3][10] = - { { 1, 3, 0, 7, 5, 2, 9, 6, 4, 8 }, - { 6, 1, 9, 3, 8, 5, 7, 4, 0, 2 }, - { 4, 0, 3, 5, 7, 2, 8, 6, 1, 9 } }; +#ifdef HAVE_CSS + /* structures defined in cdrom.h or dvdio.h */ + char p_buffer[2048 + 4 + 1]; + int i_agid = 0; + int i_ret = -1; + int i; - /* Permutation table for varient table for key2 and buskey */ - u8 ppi_perm_varient[2][32] = - { { 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 }, - { 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 } }; + /* Test authentication success */ + switch( CSSGetASF( i_fd ) ) + { + case -1: + return -1; - 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 }; + case 1: + intf_WarnMsg( 2, "css info: already authenticated" ); + return 0; - /* The "secret" key */ - u8 pi_secret[5] = { 0x55, 0xD6, 0xC4, 0xC5, 0x28 }; + case 0: + intf_WarnMsg( 2, "css info: need to authenticate" ); + } - u8 pi_bits[30]; - u8 pi_scratch[10]; - u8 pi_tmp1[5]; - u8 pi_tmp2[5]; - u8 i_lfsr0_o; /* 1 bit used */ - u8 i_lfsr1_o; /* 1 bit used */ - u32 i_lfsr0; - u32 i_lfsr1; - u8 i_css_varient; - u8 i_cse; - u8 i_index; - u8 i_combined; - u8 i_carry; - u8 i_val = 0; - int i_term = 0; - int i_bit; - int i; + /* Init sequence, request AGID */ + for( i = 1; i < 4 ; ++i ) + { + intf_WarnMsg( 2, "css info: requesting AGID %d", i ); - for (i = 9; i >= 0; --i) - pi_scratch[i] = pi_challenge[ppi_perm_challenge[i_key_type][i]]; + i_ret = ioctl_ReportAgid( i_fd, &i_agid ); - i_css_varient = ( i_key_type == 0 ) ? i_varient : - ppi_perm_varient[i_key_type-1][i_varient]; + if( i_ret != -1 ) + { + /* No error during ioctl: we know the device is authenticated */ + break; + } - /* - * 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. - */ + intf_ErrMsg( "css error: ioctl_ReportAgid failed, invalidating" ); - /* 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 ; ) + i_agid = 0; + ioctl_InvalidateAgid( i_fd, &i_agid ); + } + + /* Unable to authenticate without AGID */ + if( i_ret == -1 ) { - pi_tmp1[i] = pi_scratch[5 + i] ^ pi_secret[i] ^ pi_crypt_tab2[i]; + intf_ErrMsg( "css error: ioctl_ReportAgid failed, fatal" ); + return -1; } - /* - * 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 ); - i_lfsr1 = ( pi_tmp1[3] << 9 ) | 0x100 | pi_tmp1[4]; + for( i = 0 ; i < 10; ++i ) + { + p_css->disc.pi_challenge[i] = i; + } - i_index = sizeof(pi_bits); - i_carry = 0; + /* Get challenge from host */ + for( i = 0 ; i < 10 ; ++i ) + { + p_buffer[9-i] = p_css->disc.pi_challenge[i]; + } - do + /* Send challenge to LU */ + if( ioctl_SendChallenge( i_fd, &i_agid, p_buffer ) < 0 ) { - for( i_bit = 0, i_val = 0 ; i_bit < 8 ; ++i_bit ) - { + intf_ErrMsg( "css error: ioctl_SendChallenge failed" ); + return -1; + } - i_lfsr0_o = ( ( i_lfsr0 >> 24 ) ^ ( i_lfsr0 >> 21 ) ^ - ( i_lfsr0 >> 20 ) ^ ( i_lfsr0 >> 12 ) ) & 1; - i_lfsr0 = ( i_lfsr0 << 1 ) | i_lfsr0_o; + /* Get key1 from LU */ + if( ioctl_ReportKey1( i_fd, &i_agid, p_buffer ) < 0) + { + intf_ErrMsg( "css error: ioctl_ReportKey1 failed" ); + return -1; + } - i_lfsr1_o = ( ( i_lfsr1 >> 16 ) ^ ( i_lfsr1 >> 2 ) ) & 1; - i_lfsr1 = ( i_lfsr1 << 1 ) | i_lfsr1_o; + /* Send key1 to host */ + for( i = 0 ; i < KEY_SIZE ; i++ ) + { + p_css->disc.pi_key1[i] = p_buffer[4-i]; + } -#define BIT0(x) ((x) & 1) -#define BIT1(x) (((x) >> 1) & 1) + for( i = 0 ; i < 32 ; ++i ) + { + CSSCryptKey( 0, i, p_css->disc.pi_challenge, + p_css->disc.pi_key_check ); - 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; + if( memcmp( p_css->disc.pi_key_check, + p_css->disc.pi_key1, KEY_SIZE ) == 0 ) + { + intf_WarnMsg( 2, "css info: drive authentic, using variant %d", i); + p_css->disc.i_varient = i; + break; } - - pi_bits[--i_index] = i_val; - } while( i_index > 0 ); - - /* 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]; + } - /* 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] ) + if( i == 32 ) { - i_index = pi_bits[25 + i] ^ pi_scratch[i]; - i_index = pi_crypt_tab1[i_index] ^ ~pi_crypt_tab2[i_index] ^ i_cse; + intf_ErrMsg( "css error: drive would not authenticate" ); + return -1; + } - pi_tmp1[i] = pi_crypt_tab2[i_index] ^ pi_crypt_tab3[i_index] ^ i_term; + /* Get challenge from LU */ + if( ioctl_ReportChallenge( i_fd, &i_agid, p_buffer ) < 0 ) + { + intf_ErrMsg( "css error: ioctl_ReportKeyChallenge failed" ); + return -1; } - pi_tmp1[4] ^= pi_tmp1[0]; - for( i = 5, i_term = 0 ; --i >= 0 ; i_term = pi_tmp1[i] ) + /* Send challenge to host */ + for( i = 0 ; i < 10 ; ++i ) { - i_index = pi_bits[20 + i] ^ pi_tmp1[i]; - i_index = pi_crypt_tab1[i_index] ^ ~pi_crypt_tab2[i_index] ^ i_cse; + p_css->disc.pi_challenge[i] = p_buffer[9-i]; + } - pi_tmp2[i] = pi_crypt_tab2[i_index] ^ pi_crypt_tab3[i_index] ^ i_term; + CSSCryptKey( 1, p_css->disc.i_varient, p_css->disc.pi_challenge, + p_css->disc.pi_key2 ); + + /* Get key2 from host */ + for( i = 0 ; i < KEY_SIZE ; ++i ) + { + p_buffer[4-i] = p_css->disc.pi_key2[i]; } - pi_tmp2[4] ^= pi_tmp2[0]; - for( i = 5, i_term = 0 ; --i >= 0 ; i_term = pi_tmp2[i] ) + /* Send key2 to LU */ + if( ioctl_SendKey2( i_fd, &i_agid, p_buffer ) < 0 ) { - 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; + intf_ErrMsg( "css error: ioctl_SendKey2 failed" ); + return -1; + } - pi_tmp1[i] = pi_crypt_tab0[i_index] ^ pi_crypt_tab2[i_index]; + intf_WarnMsg( 2, "css info: authentication established" ); + + memcpy( p_css->disc.pi_challenge, p_css->disc.pi_key1, KEY_SIZE ); + memcpy( p_css->disc.pi_challenge+KEY_SIZE, p_css->disc.pi_key2, KEY_SIZE ); + + CSSCryptKey( 2, p_css->disc.i_varient, p_css->disc.pi_challenge, + p_css->disc.pi_key_check ); + + intf_WarnMsg( 2, "css info: received session key" ); + + if( i_agid < 0 ) + { + return -1; } - pi_tmp1[4] ^= pi_tmp1[0]; - for( i = 5, i_term = 0 ; --i >= 0 ; i_term = pi_tmp1[i] ) + /* Test authentication success */ + switch( CSSGetASF( i_fd ) ) { - i_index = pi_bits[10 + i] ^ pi_tmp1[i]; - i_index = pi_crypt_tab1[i_index] ^ ~pi_crypt_tab2[i_index] ^ i_cse; + case -1: + return -1; - i_index = pi_crypt_tab2[i_index] ^ pi_crypt_tab3[i_index] ^ i_term; + case 1: + intf_WarnMsg( 2, "css info: already authenticated" ); + return 0; - pi_tmp2[i] = pi_crypt_tab0[i_index] ^ pi_crypt_tab2[i_index]; + case 0: + intf_WarnMsg( 2, "css info: need to get disc key" ); } - pi_tmp2[4] ^= pi_tmp2[0]; - for( i = 5, i_term = 0 ; --i >= 0 ; i_term = pi_tmp2[i] ) + /* Get encrypted disc key */ + if( ioctl_ReadKey( i_fd, &i_agid, p_buffer ) < 0 ) { - i_index = pi_bits[5 + i] ^ pi_tmp2[i]; - i_index = pi_crypt_tab1[i_index] ^ ~pi_crypt_tab2[i_index] ^ i_cse; + intf_ErrMsg( "css error: ioctl_ReadKey failed" ); + return -1; + } - pi_tmp1[i] = pi_crypt_tab2[i_index] ^ pi_crypt_tab3[i_index] ^ i_term; + /* Unencrypt disc key using bus key */ + for( i = 0 ; i < 2048 ; i++ ) + { + p_buffer[ i ] ^= p_css->disc.pi_key_check[ 4 - (i % KEY_SIZE) ]; } - pi_tmp1[4] ^= pi_tmp1[0]; + memcpy( p_css->disc.pi_key_check, p_buffer, 2048 ); - for(i = 5, i_term = 0 ; --i >= 0 ; i_term = pi_tmp1[i] ) + /* initialize title key to know it empty */ + for( i = 0 ; i < KEY_SIZE ; i++ ) { - i_index = pi_bits[i] ^ pi_tmp1[i]; - i_index = pi_crypt_tab1[i_index] ^ ~pi_crypt_tab2[i_index] ^ i_cse; + p_css->pi_title_key[i] = 0; + } - pi_key[i] = pi_crypt_tab2[i_index] ^ pi_crypt_tab3[i_index] ^ i_term; + /* Test authentication success */ + switch( CSSGetASF( i_fd ) ) + { + case -1: + return -1; + + case 1: + intf_WarnMsg( 2, "css info: successfully authenticated" ); + return 0; + + case 0: + intf_ErrMsg( "css error: no way to authenticate" ); + return -1; } - return; -} +#else /* HAVE_CSS */ + intf_ErrMsg( "css error: CSS decryption is disabled in this module" ); + +#endif /* HAVE_CSS */ + return -1; + +} /***************************************************************************** - * CSSCracker : title key decryption by cracking - * --- - * This function is called by CSSGetKeys to find a key + * CSSGetKey : get title key. + ***************************************************************************** + * The DVD should have been opened and authenticated before. *****************************************************************************/ -static int CSSCracker( int i_start, - unsigned char * p_crypted, - unsigned char * p_decrypted, - dvd_key_t * p_sector_key, - dvd_key_t * p_key ) +int CSSGetKey( int i_fd, css_t * p_css ) { - unsigned char pi_buffer[10]; - unsigned int i_t1, i_t2, i_t3, i_t4, i_t5, i_t6; - unsigned int i_try; - unsigned int i_candidate; - unsigned int i, j; - int i_exit = -1; - +#ifdef HAVE_CSS + /* + * Title key cracking method from Ethan Hawke, + * with Frank A. Stevenson algorithm. + * Does not use any player key table and ioctls. + */ + u8 pi_buf[0x800]; + dvd_key_t pi_key; + off_t i_pos; + boolean_t b_encrypted; + boolean_t b_stop_scanning; + int i_bytes_read; + int i_best_plen; + int i_best_p; + int i,j; - for( i = 0 ; i < 10 ; i++ ) + for( i = 0 ; i < KEY_SIZE ; i++ ) { - pi_buffer[i] = pi_css_tab1[p_crypted[i]] ^ p_decrypted[i]; + pi_key[i] = 0; } - for( i_try = i_start ; i_try < 0x10000 ; i_try++ ) - { - i_t1 = i_try >> 8 | 0x100; - i_t2 = i_try & 0xff; - i_t3 = 0; /* not needed */ - i_t5 = 0; - - /* iterate cipher 4 times to reconstruct LFSR2 */ - for( i = 0 ; i < 4 ; i++ ) - { - /* advance LFSR1 normaly */ - i_t4 = pi_css_tab2[i_t2] ^ pi_css_tab3[i_t1]; - i_t2 = i_t1 >> 1; - i_t1 = ( ( i_t1 & 1 ) << 8 ) ^ i_t4; - i_t4 = pi_css_tab5[i_t4]; - /* deduce i_t6 & i_t5 */ - i_t6 = pi_buffer[i]; - if( i_t5 ) - { - i_t6 = ( i_t6 + 0xff ) & 0x0ff; - } - if( i_t6 < i_t4 ) - { - i_t6 += 0x100; - } - i_t6 -= i_t4; - i_t5 += i_t6 + i_t4; - i_t6 = pi_css_tab4[ i_t6 ]; - /* feed / advance i_t3 / i_t5 */ - i_t3 = ( i_t3 << 8 ) | i_t6; - i_t5 >>= 8; - } + b_encrypted = 0; + b_stop_scanning = 0; - i_candidate = i_t3; + /* Position of the title on the disc */ + i_pos = p_css->i_title_pos; - /* iterate 6 more times to validate candidate key */ - for( ; i < 10 ; i++ ) - { - i_t4 = pi_css_tab2[i_t2] ^ pi_css_tab3[i_t1]; - i_t2 = i_t1 >> 1; - i_t1 = ( ( i_t1 & 1 ) << 8 ) ^ i_t4; - i_t4 = pi_css_tab5[i_t4]; - i_t6 = ((((((( i_t3 >> 3 ) ^ i_t3 ) >> 1 ) ^ - i_t3 ) >> 8 ) ^ i_t3 ) >> 5 ) & 0xff; - i_t3 = ( i_t3 << 8 ) | i_t6; - i_t6 = pi_css_tab4[i_t6]; - i_t5 += i_t6 + i_t4; - if( ( i_t5 & 0xff ) != pi_buffer[i] ) - { - break; - } + do { + i_pos = lseek( i_fd, i_pos, SEEK_SET ); + i_bytes_read = read( i_fd, pi_buf, 0x800 ); - i_t5 >>= 8; - } + /* PES_scrambling_control */ + if( pi_buf[0x14] & 0x30 ) + { + b_encrypted = 1; + i_best_plen = 0; + i_best_p = 0; - if( i == 10 ) + for( i = 2 ; i < 0x30 ; i++ ) { - /* Do 4 backwards steps of iterating t3 to deduce initial state */ - i_t3 = i_candidate; - for( i = 0 ; i < 4 ; i++ ) + for( j = i ; ( j < 0x80 ) && + ( pi_buf[0x7F - (j%i)] == pi_buf[0x7F-j] ) ; j++ ); { - i_t1 = i_t3 & 0xff; - i_t3 = ( i_t3 >> 8 ); - /* easy to code, and fast enough bruteforce - * search for byte shifted in */ - for( j = 0 ; j < 256 ; j++ ) + if( ( j > i_best_plen ) && ( j > i ) ) { - i_t3 = ( i_t3 & 0x1ffff) | ( j << 17 ); - i_t6 = ((((((( i_t3 >> 3 ) ^ i_t3 ) >> 1 ) ^ - i_t3 ) >> 8 ) ^ i_t3 ) >> 5 ) & 0xff; - if( i_t6 == i_t1 ) - { - break; - } + i_best_plen = j; + i_best_p = i; } } + } - i_t4 = ( i_t3 >> 1 ) - 4; - for( i_t5 = 0 ; i_t5 < 8; i_t5++ ) - { - if( ( ( i_t4 + i_t5 ) * 2 + 8 - ( (i_t4 + i_t5 ) & 7 ) ) - == i_t3 ) - { - (*p_key)[0] = i_try>>8; - (*p_key)[1] = i_try & 0xFF; - (*p_key)[2] = ( ( i_t4 + i_t5 ) >> 0) & 0xFF; - (*p_key)[3] = ( ( i_t4 + i_t5 ) >> 8) & 0xFF; - (*p_key)[4] = ( ( i_t4 + i_t5 ) >> 16) & 0xFF; - i_exit = i_try + 1; - } - } + if( ( i_best_plen > 20 ) && ( i_best_plen / i_best_p >= 2) ) + { + i = CSSCracker( 0, &pi_buf[0x80], + &pi_buf[0x80 - ( i_best_plen / i_best_p) *i_best_p], + (dvd_key_t*)&pi_buf[0x54], + &pi_key ); + b_stop_scanning = ( i >= 0 ); } } - if( i_exit >= 0 ) + i_pos += i_bytes_read; + } while( i_bytes_read == 0x800 && !b_stop_scanning); + + if( b_stop_scanning) { - (*p_key)[0] ^= (*p_sector_key)[0]; - (*p_key)[1] ^= (*p_sector_key)[1]; - (*p_key)[2] ^= (*p_sector_key)[2]; - (*p_key)[3] ^= (*p_sector_key)[3]; - (*p_key)[4] ^= (*p_sector_key)[4]; + memcpy( p_css->pi_title_key, + &pi_key, sizeof(dvd_key_t) ); + intf_WarnMsg( 2, "css info: vts key initialized" ); + return 0; } - return i_exit; -} - -/* - * Authentication and keys - */ - -/***************************************************************************** - * CSSTest : check if the disc is encrypted or not - *****************************************************************************/ -int CSSTest( int i_fd ) -{ - dvd_struct dvd; - - dvd.type = DVD_STRUCT_COPYRIGHT; - dvd.copyright.layer_num = 0; - - if( dvd_ioctl( i_fd, DVD_READ_STRUCT, &dvd ) < 0 ) + if( !b_encrypted ) { - intf_ErrMsg( "DVD ioctl error" ); - return -1; + intf_WarnMsg( 2, "css warning: this file was _NOT_ encrypted!" ); + return 0; } - return dvd.copyright.cpst; + return -1; + +#else /* HAVE_CSS */ + intf_ErrMsg( "css error: css decryption unavailable" ); + return -1; + +#endif /* HAVE_CSS */ } /***************************************************************************** - * CSSInit : CSS Structure initialisation and DVD authentication. - * It simulates the mutual authentication between logical unit and host. - * --- - * Since we don't need the disc key to find the title key, we just run the - * basic unavoidable commands to authenticate device and disc. + * CSSDescrambleSector + ***************************************************************************** + * sec : sector to descramble + * key : title key for this sector *****************************************************************************/ - -css_t CSSInit( int i_fd ) +int CSSDescrambleSector( dvd_key_t pi_key, u8* pi_sec ) { - /* structures defined in cdrom.h or dvdio.h */ - dvd_authinfo auth_info; - dvd_struct dvd; - - css_t css; - int i_error = -1; - int i; - - css.i_fd = i_fd; - css.b_error = 0; - - memset( &auth_info, 0, sizeof(auth_info) ); +#ifdef HAVE_CSS + unsigned int i_t1, i_t2, i_t3, i_t4, i_t5, i_t6; + u8* pi_end = pi_sec + 0x800; - /* Test authentication success */ - switch( CSSGetASF( i_fd ) ) + /* PES_scrambling_control */ + if( pi_sec[0x14] & 0x30) { - case -1: - css.b_error = 1; - case 1: - return css; - case 0: - intf_WarnMsg( 3, "CSS: Authenticating" ); - } + i_t1 = ((pi_key)[0] ^ pi_sec[0x54]) | 0x100; + i_t2 = (pi_key)[1] ^ pi_sec[0x55]; + i_t3 = (((pi_key)[2]) | ((pi_key)[3] << 8) | + ((pi_key)[4] << 16)) ^ ((pi_sec[0x56]) | + (pi_sec[0x57] << 8) | (pi_sec[0x58] << 16)); + i_t4 = i_t3 & 7; + i_t3 = i_t3 * 2 + 8 - i_t4; + pi_sec += 0x80; + i_t5 = 0; - /* Init sequence, request AGID */ - for( i = 1; i < 4 ; ++i ) - { - intf_WarnMsg( 3, "CSS: Request AGID %d", i ); - auth_info.type = DVD_LU_SEND_AGID; - auth_info.lsa.agid = 0; - i_error = dvd_ioctl( i_fd, DVD_AUTH, &auth_info ); - if( i_error != -1 ) + while( pi_sec != pi_end ) { - /* No error during ioctl: we know if device - * is authenticated */ - break; + i_t4 = pi_css_tab2[i_t2] ^ pi_css_tab3[i_t1]; + i_t2 = i_t1>>1; + i_t1 = ( ( i_t1 & 1 ) << 8 ) ^ i_t4; + i_t4 = pi_css_tab5[i_t4]; + i_t6 = ((((((( i_t3 >> 3 ) ^ i_t3 ) >> 1 ) ^ + i_t3 ) >> 8 ) ^ i_t3 ) >> 5) & 0xff; + i_t3 = (i_t3 << 8 ) | i_t6; + i_t6 = pi_css_tab4[i_t6]; + i_t5 += i_t6 + i_t4; + *pi_sec = pi_css_tab1[*pi_sec] ^( i_t5 & 0xff ); + pi_sec++; + i_t5 >>= 8; } - - intf_ErrMsg( "CSS: AGID N/A, invalidating" ); - auth_info.type = DVD_INVALIDATE_AGID; - auth_info.lsa.agid = 0; - dvd_ioctl( i_fd, DVD_AUTH, &auth_info ); - } - - /* Unable to authenticate without AGID */ - if( i_error == -1 ) - { - css.b_error = 1; - intf_ErrMsg( "CSS: Cannot get AGID" ); - return css; } - for( i = 0 ; i < 10; ++i ) - { - css.disc.pi_challenge[i] = i; - } + return 0; - /* Send AGID to host */ - auth_info.type = DVD_HOST_SEND_CHALLENGE; +#else /* HAVE_CSS */ + return 1; - /* Get challenge from host */ - for( i = 0 ; i < 10 ; ++i ) - { - auth_info.hsc.chal[9-i] = css.disc.pi_challenge[i]; - } - /* Returning data, let LU change state */ - css.i_agid = auth_info.lsa.agid; +#endif /* HAVE_CSS */ +} - /* Send challenge to LU */ - if( dvd_ioctl( i_fd, DVD_AUTH, &auth_info )<0 ) - { - intf_ErrMsg( "CSS: Send challenge to LU failed "); - css.b_error = 1; - return css; - } +#ifdef HAVE_CSS - /* Get key1 from LU */ - if( dvd_ioctl( i_fd, DVD_AUTH, &auth_info ) < 0) - { - intf_ErrMsg( "CSS: Get key1 from LU failed "); - css.b_error = 1; - return css; - } +/* Following functions are local */ - /* Send key1 to host */ - for( i = 0 ; i < KEY_SIZE ; i++ ) - { - css.disc.pi_key1[i] = auth_info.lsk.key[4-i]; - } +/***************************************************************************** + * CSSGetASF : Get Authentification success flag + ***************************************************************************** + * Returns : + * -1 on ioctl error, + * 0 if the device needs to be authenticated, + * 1 either. + *****************************************************************************/ +static int CSSGetASF( int i_fd ) +{ + int i_agid; + int i_asf = 0; - for( i = 0 ; i < 32 ; ++i ) + for( i_agid = 0 ; i_agid < 4 ; i_agid++ ) { - CSSCryptKey( 0, i, css.disc.pi_challenge, - css.disc.pi_key_check ); - - if( memcmp( css.disc.pi_key_check, - css.disc.pi_key1, KEY_SIZE ) == 0 ) + if( ioctl_ReportASF( i_fd, &i_agid, &i_asf ) == 0 ) { - intf_WarnMsg( 3, "CSS: Drive Authentic - using varient %d", i); - css.disc.i_varient = i; - auth_info.type = DVD_LU_SEND_CHALLENGE; - break; - } - } - - if( i == 32 ) - { - intf_ErrMsg( "Drive would not Authenticate" ); - auth_info.type = DVD_AUTH_FAILURE; - css.b_error = 1; - return css; - } + intf_WarnMsg( 3, "css info: GetASF %sauthenticated", + i_asf ? "":"not " ); - /* Get challenge from LU */ - if( dvd_ioctl( i_fd, DVD_AUTH, &auth_info ) < 0 ) - { - intf_ErrMsg( "CSS: Get challenge from LU failed "); - css.b_error = 1; - return css; - } - - /* Send challenge to host */ - for( i = 0 ; i < 10 ; ++i ) - { - css.disc.pi_challenge[i] = auth_info.hsc.chal[9-i]; + return i_asf; + } } - CSSCryptKey( 1, css.disc.i_varient, css.disc.pi_challenge, - css.disc.pi_key2 ); - auth_info.type = DVD_HOST_SEND_KEY2; + /* The ioctl process has failed */ + intf_ErrMsg( "css error: GetASF fatal error" ); + return -1; +} - /* Get key2 from host */ - for( i = 0 ; i < KEY_SIZE ; ++i ) - { - auth_info.hsk.key[4-i] = css.disc.pi_key2[i]; - } - /* Returning data, let LU change state */ +/***************************************************************************** + * CSSCryptKey : shuffles bits and unencrypt keys. + ***************************************************************************** + * Used during authentication and disc key negociation in CSSInit. + * i_key_type : 0->key1, 1->key2, 2->buskey. + * i_varient : between 0 and 31. + *****************************************************************************/ +static void CSSCryptKey( int i_key_type, int i_varient, + u8 const * pi_challenge, u8* pi_key ) +{ + /* Permutation table for challenge */ + u8 ppi_perm_challenge[3][10] = + { { 1, 3, 0, 7, 5, 2, 9, 6, 4, 8 }, + { 6, 1, 9, 3, 8, 5, 7, 4, 0, 2 }, + { 4, 0, 3, 5, 7, 2, 8, 6, 1, 9 } }; - /* Send key2 to LU */ - if( dvd_ioctl( i_fd, DVD_AUTH, &auth_info ) < 0 ) - { - intf_ErrMsg( "CSS: Send key2 to LU failed (expected)" ); - return css; - } + /* Permutation table for varient table for key2 and buskey */ + u8 ppi_perm_varient[2][32] = + { { 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 }, + { 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 } }; - if( auth_info.type == DVD_AUTH_ESTABLISHED ) - { - intf_WarnMsg( 3, "CSS: Authentication established"); - } - else if( auth_info.type == DVD_AUTH_FAILURE ) - { - css.b_error = 1; - intf_ErrMsg("CSS: DVD authentication failed"); - } + 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 }; - memcpy( css.disc.pi_challenge, css.disc.pi_key1, KEY_SIZE ); - memcpy( css.disc.pi_challenge+KEY_SIZE, css.disc.pi_key2, KEY_SIZE ); - CSSCryptKey( 2, css.disc.i_varient, - css.disc.pi_challenge, - css.disc.pi_key_check ); + /* The "secret" key */ + u8 pi_secret[5] = { 0x55, 0xD6, 0xC4, 0xC5, 0x28 }; - intf_WarnMsg( 1, "CSS: Received Session Key" ); + u8 pi_bits[30]; + u8 pi_scratch[10]; + u8 pi_tmp1[5]; + u8 pi_tmp2[5]; + u8 i_lfsr0_o; /* 1 bit used */ + u8 i_lfsr1_o; /* 1 bit used */ + u32 i_lfsr0; + u32 i_lfsr1; + u8 i_css_varient; + u8 i_cse; + u8 i_index; + u8 i_combined; + u8 i_carry; + u8 i_val = 0; + int i_term = 0; + int i_bit; + int i; - if( css.i_agid < 0 ) - { - css.b_error = 1; - return css; - } + for (i = 9; i >= 0; --i) + pi_scratch[i] = pi_challenge[ppi_perm_challenge[i_key_type][i]]; - /* Test authentication success */ - switch( CSSGetASF( i_fd ) ) - { - case -1: - css.b_error = 1; - case 1: - return css; - case 0: - intf_WarnMsg( 3, "CSS: Getting disc key" ); - } + i_css_varient = ( i_key_type == 0 ) ? i_varient : + ppi_perm_varient[i_key_type-1][i_varient]; - /* Get encrypted disc key */ - dvd.type = DVD_STRUCT_DISCKEY; - dvd.disckey.agid = css.i_agid; - memset( dvd.disckey.value, 0, 2048 ); + /* + * 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. + */ - if( dvd_ioctl( i_fd, DVD_READ_STRUCT, &dvd ) < 0 ) - { - intf_ErrMsg( "CSS: Could not read Disc Key" ); - css.b_error = 1; - return css; - } -#if 1 - /* Unencrypt disc key using bus key */ - for( i = 0 ; i < sizeof(dvd.disckey.value) ; i++ ) - { - dvd.disckey.value[i] ^= css.disc.pi_key_check[4 - (i % KEY_SIZE)]; - } - memcpy( css.disc.pi_key_check, dvd.disckey.value, 2048 ); -#endif - /* Test authentication success */ - switch( CSSGetASF( i_fd ) ) + /* 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 ; ) { - case -1: - case 0: - css.b_error = 1; - case 1: - return css; + pi_tmp1[i] = pi_scratch[5 + i] ^ pi_secret[i] ^ pi_crypt_tab2[i]; } - return css; -} - -/***************************************************************************** - * CSSGetKey : get title key. - * The DVD should have been opened and authenticated before. - *****************************************************************************/ -int CSSGetKey( css_t * p_css ) -{ /* - * Title key cracking method from Ethan Hawke, - * with Frank A. Stevenson algorithm. - * Does not use any player key table and ioctls. - */ - u8 pi_buf[0x800]; - dvd_key_t pi_key; - title_key_t p_title_key[10]; - off_t i_pos; - boolean_t b_encrypted; - boolean_t b_stop_scanning; - int i_title; - int i_bytes_read; - int i_best_plen; - int i_best_p; - int i_registered_keys; - int i_total_keys_found; - int i_highest; - int i,j,k; - - memset( p_title_key, 0, 10 ); - memset( &pi_key, 0, 10 ); - b_encrypted = 0; - b_stop_scanning = 0; - i_registered_keys = 0 ; - i_total_keys_found = 0 ; - i_highest = 0; - - /* Position of the title on the disc */ - i_title = p_css->i_title; - i_pos = p_css->i_title_pos; - -//fprintf( stderr, "CSS %d start pos: %lld\n", i_title, i_pos ); + * 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 ); + i_lfsr1 = ( pi_tmp1[3] << 9 ) | 0x100 | pi_tmp1[4]; - do { - i_pos = lseek( p_css->i_fd, i_pos, SEEK_SET ); - i_bytes_read = read( p_css->i_fd, pi_buf, 0x800 ); + i_index = sizeof(pi_bits); + i_carry = 0; - /* PES_scrambling_control */ - if( pi_buf[0x14] & 0x30 ) + do { - b_encrypted = 1; - i_best_plen = 0; - i_best_p = 0; - - for( i = 2 ; i < 0x30 ; i++ ) + for( i_bit = 0, i_val = 0 ; i_bit < 8 ; ++i_bit ) { - for( j = i ; ( j < 0x80 ) && - ( pi_buf[0x7F - (j%i)] == pi_buf[0x7F-j] ) ; j++ ); - { - if( ( j > i_best_plen ) && ( j > i ) ) - { - i_best_plen = j; - i_best_p = i; - } - } - } - if( ( i_best_plen > 20 ) && ( i_best_plen / i_best_p >= 2) ) - { - i = CSSCracker( 0, &pi_buf[0x80], - &pi_buf[0x80 - ( i_best_plen / i_best_p) *i_best_p], - (dvd_key_t*)&pi_buf[0x54], - &pi_key ); - while( i>=0 ) - { - k = 0; - for( j=0 ; j> 24 ) ^ ( i_lfsr0 >> 21 ) ^ + ( i_lfsr0 >> 20 ) ^ ( i_lfsr0 >> 12 ) ) & 1; + i_lfsr0 = ( i_lfsr0 << 1 ) | i_lfsr0_o; - if( k == 0 ) - { - memcpy( &(p_title_key[i_registered_keys].pi_key), - &pi_key, sizeof(dvd_key_t) ); - p_title_key[i_registered_keys++].i_occ = 1; - i_total_keys_found++; - } - i = CSSCracker( i, &pi_buf[0x80], - &pi_buf[0x80 - ( i_best_plen / i_best_p) *i_best_p], - (dvd_key_t*)&pi_buf[0x54], &pi_key); - } + i_lfsr1_o = ( ( i_lfsr1 >> 16 ) ^ ( i_lfsr1 >> 2 ) ) & 1; + i_lfsr1 = ( i_lfsr1 << 1 ) | i_lfsr1_o; - /* Stop search if we find one occurance of the key - * I have never found a DVD for which it is not enough - * but we should take care of that */ - if( i_registered_keys == 1 && p_title_key[0].i_occ >= 1 ) - { - b_stop_scanning = 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_pos += i_bytes_read; - } while( i_bytes_read == 0x800 && !b_stop_scanning); + /* 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]; - if( b_stop_scanning) + /* 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] ) { - intf_WarnMsg( 1, - "CSS: Found enough occurancies of the same key." ); + 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]; - if( !b_encrypted ) + for( i = 5, i_term = 0 ; --i >= 0 ; i_term = pi_tmp1[i] ) { - intf_WarnMsg( 3, "CSS: This file was _NOT_ encrypted!"); - return(0); + 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]; - if( b_encrypted && i_registered_keys == 0 ) + for( i = 5, i_term = 0 ; --i >= 0 ; i_term = pi_tmp2[i] ) { - intf_ErrMsg( "CSS: Unable to determine keys from file."); - return(1); + 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 = 0 ; i < i_registered_keys - 1 ; i++ ) + for( i = 5, i_term = 0 ; --i >= 0 ; i_term = pi_tmp1[i] ) { - for( j = i + 1 ; j < i_registered_keys ; j++ ) - { - if( p_title_key[j].i_occ > p_title_key[i].i_occ ) - { - memcpy( &pi_key, &(p_title_key[j].pi_key), sizeof(dvd_key_t) ); - k = p_title_key[j].i_occ; + i_index = pi_bits[10 + i] ^ pi_tmp1[i]; + i_index = pi_crypt_tab1[i_index] ^ ~pi_crypt_tab2[i_index] ^ i_cse; - memcpy( &(p_title_key[j].pi_key), - &(p_title_key[i].pi_key), sizeof(dvd_key_t) ); - p_title_key[j].i_occ = p_title_key[i].i_occ; + i_index = pi_crypt_tab2[i_index] ^ pi_crypt_tab3[i_index] ^ i_term; - memcpy( &(p_title_key[i].pi_key),&pi_key, sizeof(dvd_key_t) ); - p_title_key[i].i_occ = k; - } - } + pi_tmp2[i] = pi_crypt_tab0[i_index] ^ pi_crypt_tab2[i_index]; } + pi_tmp2[4] ^= pi_tmp2[0]; -#ifdef STATS - intf_WarnMsg( 1, " Key(s) & key probability\n---------------------"); -#endif - for( i=0 ; i= 0 ; i_term = pi_tmp2[i] ) { -#ifdef STATS - intf_WarnMsg( 1, "%d) %02X %02X %02X %02X %02X - %3.2f%%", i, - p_title_key[i].pi_key[0], p_title_key[i].pi_key[1], - p_title_key[i].pi_key[2], p_title_key[i].pi_key[3], - p_title_key[i].pi_key[4], - p_title_key[i].i_occ * 100.0 / i_total_keys_found ); -#endif - if( p_title_key[i_highest].i_occ * 100.0 / i_total_keys_found - <= p_title_key[i].i_occ*100.0 / i_total_keys_found ) - { - i_highest = i; - } - } + 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]; - /* The "find the key with the highest probability" code - * is untested, as I haven't been able to find a VOB that - * produces multiple keys (RT) - */ - intf_WarnMsg( 3, "CSS: Title %d key: %02X %02X %02X %02X %02X", - i_title, - p_title_key[i_highest].pi_key[0], - p_title_key[i_highest].pi_key[1], - p_title_key[i_highest].pi_key[2], - p_title_key[i_highest].pi_key[3], - p_title_key[i_highest].pi_key[4] ); + for(i = 5, i_term = 0 ; --i >= 0 ; i_term = pi_tmp1[i] ) + { + i_index = pi_bits[i] ^ pi_tmp1[i]; + i_index = pi_crypt_tab1[i_index] ^ ~pi_crypt_tab2[i_index] ^ i_cse; - memcpy( p_css->pi_title_key, - p_title_key[i_highest].pi_key, KEY_SIZE ); + pi_key[i] = pi_crypt_tab2[i_index] ^ pi_crypt_tab3[i_index] ^ i_term; + } - return 0; + return; } /***************************************************************************** - * CSSDescrambleSector - * --- - * sec : sector to descramble - * key : title key for this sector + * CSSCracker : title key decryption by cracking + ***************************************************************************** + * This function is called by CSSGetKeys to find a key *****************************************************************************/ -int CSSDescrambleSector( dvd_key_t pi_key, u8* pi_sec ) +static int CSSCracker( int i_start, + unsigned char * p_crypted, + unsigned char * p_decrypted, + dvd_key_t * p_sector_key, + dvd_key_t * p_key ) { - unsigned int i_t1, i_t2, i_t3, i_t4, i_t5, i_t6; - u8* pi_end = pi_sec + 0x800; + unsigned char pi_buffer[10]; + unsigned int i_t1, i_t2, i_t3, i_t4, i_t5, i_t6; + unsigned int i_try; + unsigned int i_candidate; + unsigned int i, j; + int i_exit = -1; - /* PES_scrambling_control */ - if( pi_sec[0x14] & 0x30) + + for( i = 0 ; i < 10 ; i++ ) { - i_t1 = ((pi_key)[0] ^ pi_sec[0x54]) | 0x100; - i_t2 = (pi_key)[1] ^ pi_sec[0x55]; - i_t3 = (((pi_key)[2]) | ((pi_key)[3] << 8) | - ((pi_key)[4] << 16)) ^ ((pi_sec[0x56]) | - (pi_sec[0x57] << 8) | (pi_sec[0x58] << 16)); - i_t4 = i_t3 & 7; - i_t3 = i_t3 * 2 + 8 - i_t4; - pi_sec += 0x80; + pi_buffer[i] = pi_css_tab1[p_crypted[i]] ^ p_decrypted[i]; + } + + for( i_try = i_start ; i_try < 0x10000 ; i_try++ ) + { + i_t1 = i_try >> 8 | 0x100; + i_t2 = i_try & 0xff; + i_t3 = 0; /* not needed */ i_t5 = 0; - while( pi_sec != pi_end ) + /* iterate cipher 4 times to reconstruct LFSR2 */ + for( i = 0 ; i < 4 ; i++ ) { + /* advance LFSR1 normaly */ i_t4 = pi_css_tab2[i_t2] ^ pi_css_tab3[i_t1]; - i_t2 = i_t1>>1; + i_t2 = i_t1 >> 1; + i_t1 = ( ( i_t1 & 1 ) << 8 ) ^ i_t4; + i_t4 = pi_css_tab5[i_t4]; + /* deduce i_t6 & i_t5 */ + i_t6 = pi_buffer[i]; + if( i_t5 ) + { + i_t6 = ( i_t6 + 0xff ) & 0x0ff; + } + if( i_t6 < i_t4 ) + { + i_t6 += 0x100; + } + i_t6 -= i_t4; + i_t5 += i_t6 + i_t4; + i_t6 = pi_css_tab4[ i_t6 ]; + /* feed / advance i_t3 / i_t5 */ + i_t3 = ( i_t3 << 8 ) | i_t6; + i_t5 >>= 8; + } + + i_candidate = i_t3; + + /* iterate 6 more times to validate candidate key */ + for( ; i < 10 ; i++ ) + { + i_t4 = pi_css_tab2[i_t2] ^ pi_css_tab3[i_t1]; + i_t2 = i_t1 >> 1; i_t1 = ( ( i_t1 & 1 ) << 8 ) ^ i_t4; i_t4 = pi_css_tab5[i_t4]; i_t6 = ((((((( i_t3 >> 3 ) ^ i_t3 ) >> 1 ) ^ - i_t3 ) >> 8 ) ^ i_t3 ) >> 5) & 0xff; - i_t3 = (i_t3 << 8 ) | i_t6; + i_t3 ) >> 8 ) ^ i_t3 ) >> 5 ) & 0xff; + i_t3 = ( i_t3 << 8 ) | i_t6; i_t6 = pi_css_tab4[i_t6]; i_t5 += i_t6 + i_t4; - *pi_sec++ = pi_css_tab1[*pi_sec] ^( i_t5 & 0xff ); + if( ( i_t5 & 0xff ) != pi_buffer[i] ) + { + break; + } + i_t5 >>= 8; } + + if( i == 10 ) + { + /* Do 4 backwards steps of iterating t3 to deduce initial state */ + i_t3 = i_candidate; + for( i = 0 ; i < 4 ; i++ ) + { + i_t1 = i_t3 & 0xff; + i_t3 = ( i_t3 >> 8 ); + /* easy to code, and fast enough bruteforce + * search for byte shifted in */ + for( j = 0 ; j < 256 ; j++ ) + { + i_t3 = ( i_t3 & 0x1ffff) | ( j << 17 ); + i_t6 = ((((((( i_t3 >> 3 ) ^ i_t3 ) >> 1 ) ^ + i_t3 ) >> 8 ) ^ i_t3 ) >> 5 ) & 0xff; + if( i_t6 == i_t1 ) + { + break; + } + } + } + + i_t4 = ( i_t3 >> 1 ) - 4; + for( i_t5 = 0 ; i_t5 < 8; i_t5++ ) + { + if( ( ( i_t4 + i_t5 ) * 2 + 8 - ( (i_t4 + i_t5 ) & 7 ) ) + == i_t3 ) + { + (*p_key)[0] = i_try>>8; + (*p_key)[1] = i_try & 0xFF; + (*p_key)[2] = ( ( i_t4 + i_t5 ) >> 0) & 0xFF; + (*p_key)[3] = ( ( i_t4 + i_t5 ) >> 8) & 0xFF; + (*p_key)[4] = ( ( i_t4 + i_t5 ) >> 16) & 0xFF; + i_exit = i_try + 1; + } + } + } + } + + if( i_exit >= 0 ) + { + (*p_key)[0] ^= (*p_sector_key)[0]; + (*p_key)[1] ^= (*p_sector_key)[1]; + (*p_key)[2] ^= (*p_sector_key)[2]; + (*p_key)[3] ^= (*p_sector_key)[3]; + (*p_key)[4] ^= (*p_sector_key)[4]; } - return(0); + return i_exit; } +#endif /* HAVE_CSS */ +