securityserv_udp.c

au1200 linux2.6.11 硬件解码mae驱动和maiplayer播放器源码

/* <LIC_AMD_STD>
 * Copyright (C) 2003-2005 Advanced Micro Devices, Inc.  All Rights Reserved.
 * 
 * Unless otherwise designated in writing, this software and any related 
 * documentation are the confidential proprietary information of AMD. 
 * THESE MATERIALS ARE PROVIDED "AS IS" WITHOUT ANY
 * UNLESS OTHERWISE NOTED IN WRITING, EXPRESS OR IMPLIED WARRANTY OF ANY 
 * KIND, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, 
 * NONINFRINGEMENT, TITLE, FITNESS FOR ANY PARTICULAR PURPOSE AND IN NO 
 * EVENT SHALL AMD OR ITS LICENSORS BE LIABLE FOR ANY DAMAGES WHATSOEVER. 
 * 
 * AMD does not assume any responsibility for any errors which may appear 
 * in the Materials nor any responsibility to support or update the
 * Materials.  AMD retains the right to modify the Materials at any time, 
 * without notice, and is not obligated to provide such modified 
 * Materials to you. AMD is not obligated to furnish, support, or make
 * any further information available to you.
 * </LIC_AMD_STD>  */
/* <CTL_AMD_STD>
 * </CTL_AMD_STD>  */
/* <DOC_AMD_STD>
 * This is a security udp server which provide:
 * 
 * 1.  encoded serial number string for clients.
 * 2.  consistency checks for serial number files
 * 3.  hostid consistency check
 * 4.  obfuscate client serial number file access
 * 5.  recovers damaged serial number files
 * 
 * In some ways this is just a glorified file read.
 * </DOC_AMD_STD>  */

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include "linux/nvram.h"  // this should point kernel nvram.h

#include <sys/time.h>
#include <sys/resource.h>

#define NEED_HW_SECRET
#define SEC_NEEDKEYS

#include "mae_interface.h"
#include "base64.h"
#include "secure_serial.h"
#include "secure_serial_priv.h"

#ifndef TRUE
#define TRUE -1
#endif

#ifndef FALSE
#define FALSE 0
#endif

static netMsg               gNetMsg;
static u_int8_t             gDivxKeyMsg[SHA1_DIGEST_LENGTH];
static unsigned char        gDrm[HARDWARE_SECRET_SIZE];

static int                  needHwSecret=TRUE;
static int                  nvramfd=-1;

static int  myGetHwSecret()
{
  int fd;
  int i;
  int rc;
  unsigned int drm[HARDWARE_SECRET_SIZE/4];
  
  fd = open("/dev/mae",O_RDONLY);
  if (fd < 0)
    {
      return(SERIAL_MAE_DEV_OPEN);
    } 
     
  rc = ioctl(fd,AU1XXXMAE_GETDIVXSTR,drm);
  if (rc < 0)
    {
      close(fd);
      return(SERIAL_MAE_DEV_IOCTL);
    } 
  
  for (i=0;i<8;i++)
    drm[i] = drm[i] ^ salt[i];
    
  needHwSecret=FALSE;  
  close(fd);


  // This loop takes an array of 8 32 bit words and formats them
  // into 32 bytes
  for(i=0;i<8;i++)
    {
      int j,k=0;
      unsigned char *cPtr;
      cPtr = (unsigned char *)&drm[i];
      for(j=3;j>=0;j--)
        {
          gDrm[i*4+j] = cPtr[k++];                  
        }      
    }
    

  // format into a fixed length string
  //sprintf(gDrm,"%08x%08x%08x%08x%08x%08x%08x%08x",
   // drm[0],drm[1],drm[2],drm[3],drm[4],drm[5],drm[6],drm[7]);     
#ifdef DEBUG    
  printf("%08x-%08x-%08x-%08x-%08x-%08x-%08x-%08x\n",drm[0],drm[1],drm[2],drm[3],
    drm[4],drm[5],drm[6],drm[7]); 
#endif   
 
  return(SERIAL_STATUS_OK); 
  
}

static void setDivxKey()
{
 
    SHA1_CTX context;

    u_int8_t digest[SHA1_DIGEST_LENGTH];

    int i;
             
    SHA1Init(&context);
    SHA1Update(&context, gNetMsg.serialNum, strlen(gNetMsg.serialNum));
    SHA1Update(&context, gNetMsg.sig, strlen(gNetMsg.sig));
    SHA1Update(&context, "QvikGenivfNZQ",strlen("QvikGenivfNZQ"));
    SHA1Final(digest,&context);
    
    for(i=1;i<SHA1_DIGEST_LENGTH-1;i++)
      digest[i+1] = digest[i] ^ digest[i+1];
      
    SHA1Init(&context);
    SHA1Update(&context, digest, SHA1_DIGEST_LENGTH);
    SHA1Update(&context, "QvikGenivfNZQ",strlen("QvikGenivfNZQ"));   
    SHA1Final(gDivxKeyMsg,&context);
    
    for (i = sizeof(gDivxKeyMsg) - 1; i > 0; i--)    
          gDivxKeyMsg[i] = gDivxKeyMsg[i] ^ gDivxKeyMsg[i-1];
 
}
int main(int argc, char *argv[]) 
{
  int sock, length, fromlen, n;
  struct sockaddr_in server;
  struct sockaddr_in from;
  
  char *serialNum;
  char buf[1024];
  int rc;
#ifdef DEBUG
  int i;
#endif   

  nvramfd = oemOpenNVRam();
  if (nvramfd != SERIAL_STATUS_OK)
  {
    perror("NVRAM Driver not found. Exiting");
    return(-1);
  }
    
	serialNum = oemGetSerialNum(&rc);
	if (serialNum == NULL)
  {
    oemSecurityAlertCB(rc,NULL);
    return(0);
  }
  
  if (SERIAL_STATUS_OK != rc)
  {
    oemSecurityAlertCB(rc,NULL);
    return(rc);
  }

  strcpy(gNetMsg.serialNum,serialNum);
  
  gNetMsg.hostid = gethostid();
  gNetMsg.status = SERIAL_STATUS_OK;
  strcpy(gNetMsg.sig,hashSerial(serialNum,keyArray));
  
  setDivxKey();
   
#ifdef DEBUG   
  for(i=0;i<	SHA1_DIGEST_LENGTH;i++)
    fprintf(stderr,"%x",gDivxKeyMsg[i]);
    
  fprintf(stderr,"\n");
    
#else
  rc=daemon(TRUE,TRUE);  // send the process to the background
  if (rc)
  {
    oemSecurityAlertCB(SERIAL_FORK_FAILED,NULL);
    return(-1);
  }
#endif
  sock=socket(AF_INET, SOCK_DGRAM, 0);
  if (sock < 0)
  {
    oemSecurityAlertCB(SERIAL_SOCKET_ERROR,"socket call");
  }
  
  length = sizeof(server);
  memset(&server,0,length);
  server.sin_family=AF_INET;
  server.sin_addr.s_addr=INADDR_ANY;
  server.sin_port=htons(SEC_PORT);
  if (bind(sock,(struct sockaddr *)&server,length)<0)
  {
    oemSecurityAlertCB(SERIAL_SOCKET_ERROR,"bind call");
  }
  
  fromlen = sizeof(struct sockaddr_in);
   	
  while (1) {
    n = recvfrom(sock,buf,1024,0,(struct sockaddr *)&from,&fromlen);
    if (n < 0)
    {
      oemSecurityAlertCB(SERIAL_SOCKET_ERROR,"recvfrom call");
    }

    if ((n == 49) && buf[0] == SET_DIVX_DATA)  // divx data
    {
      char t[5];
      t[0] = oemWriteDivxData(&buf[1]);
      n = sendto(sock,t,sizeof(t),0,(struct sockaddr *)&from,fromlen);
      if (n  < 0)
      {
        oemSecurityAlertCB(SERIAL_SOCKET_ERROR,"sendto call");
      }
    }
    else if (buf[COMMAND_OFFSET] == GET_DIVX_DATA)
    {
      char divxData[49];
      divxData[0] = oemReadDivxData(&divxData[1]);
      n = sendto(sock,divxData,sizeof(divxData),0,(struct sockaddr *)&from,fromlen);
      if (n  < 0)
      {
        oemSecurityAlertCB(SERIAL_SOCKET_ERROR,"sendto call");
      }      
    }
    else if (buf[COMMAND_OFFSET] == GET_SERIAL_NUM)
    {
      n = sendto(sock,&gNetMsg,sizeof(gNetMsg),0,(struct sockaddr *)&from,fromlen);
      if (n  < 0)
      {
        oemSecurityAlertCB(SERIAL_SOCKET_ERROR,"sendto call");
      }
      
    } 
    else if (buf[COMMAND_OFFSET] == GET_DIVX_KEY)
    {
      n = sendto(sock,&gDivxKeyMsg,SHA1_DIGEST_LENGTH,0,(struct sockaddr *)&from,fromlen);
      if (n  < 0)
      {
        oemSecurityAlertCB(SERIAL_SOCKET_ERROR,"sendto call");
      }
    } 
    else if (buf[COMMAND_OFFSET] == GET_HARDWARE_SECRET)
    {
      if (needHwSecret)  // call if we need it.
        myGetHwSecret();
      n = sendto(sock,gDrm,sizeof(gDrm),0,(struct sockaddr *)&from,fromlen);
      if (n  < 0) 
      {
        oemSecurityAlertCB(SERIAL_SOCKET_ERROR,"sendto call");
      }
    }
    else if (buf[COMMAND_OFFSET] == GET_MODEL_STRING)
    {
      char *modelStr;
      int errorCode;
      
      modelStr = oemGetModelStr(&errorCode);
      
      n = sendto(sock,modelStr,strlen(modelStr),0,(struct sockaddr *)&from,fromlen);
      if (n  < 0) 
      {
        oemSecurityAlertCB(SERIAL_SOCKET_ERROR,"sendto call");
      }
    }
    else if (buf[COMMAND_OFFSET] == GET_MANUF_STRING)
    {
      char *manufStr;
      int  errorCode;
      
      manufStr = oemGetManufStr(&errorCode);
      
      n = sendto(sock,manufStr,strlen(manufStr),0,(struct sockaddr *)&from,fromlen);
      if (n  < 0) 
      {
        oemSecurityAlertCB(SERIAL_SOCKET_ERROR,"sendto call");
      }
    }     
        
  }
}