#include <stdlib.h>
#include <string.h>
#ifndef WIN32
#include <netinet/in.h>
#endif
#include "binary_field.h"
#include "bbtoolsapi.h"
#include "algorithms.h"
#include "bb_nn.h"
#include "aes.h"
#include "../bbboot/boot.h"
#include <PR/bbtypes.h>
#include <PR/bbcert.h>
#include <PR/bbcrl.h>
#include <PR/bbticket.h>
#include <PR/bcp.h>
#include <PR/bbvirage.h>
#include <PR/bbmetadata.h>
#include <PR/bbnand.h>
#include "../../lib/bbboot/boot.h"




/* 
 * to get virage2 data blob send input from the constant file, its size  and 
 * data from RNG and bbid from database
 * returns zero on success
 */

int 
generateVirage2Data(u32 *constantsFile,	   /* big-endian */
               u32 constantsFileLen, 
               u32 bbid, 
               BbEccPrivateKey privateKey, /* host-endian */
               BbEccPublicKey publicKey,   /* host-endian */
               u32 *rand, 		   /* host-endian */
               void *viragePtr){
    
    BbVirage2 virage;
    u32 *blob = (u32 *)viragePtr;

    int i, blobindex, index;
    u32 temp = 0x0;
    blobindex = 0;
    
    
    if(constantsFile == NULL){
        fprintf(stderr, "get input from constants file\n");
        return -1;
    }
     
    /*load hash from blob and write in */
    for(i = 0; i < 5; i++){
        virage.skHash[i] = constantsFile[blobindex];
        temp += ntohl(virage.skHash[i]);
        blobindex++;
    }
        
    for(i = 0; i < 16; i ++){
        virage.romPatch[i] = constantsFile[blobindex];
        blobindex++;
        temp += ntohl(virage.romPatch[i]);
    }
   

    virage.bbId = htonl(bbid);
    temp += bbid;
    
    /* write private key : assumes already 233 bits*/
    for(i = 0; i < 8; i++){
        virage.privateKey[i] = htonl(privateKey[i]);
        temp += privateKey[i];
        
    }
    /* remove public key later */
    
    for(i = 0; i < 16; i ++){
        virage.publicKey[i] = htonl(*(publicKey + i));
        temp += publicKey[i];
        
    }
    for(i = 0; i < 4; i++){
        virage.bootAppKey[i] = constantsFile[blobindex];
        blobindex++;
        temp += ntohl(virage.bootAppKey[i]);
                
    }
    
    /* assign the random numbers to the AES keys */
    for(i = 0; i < 4; i++){
        virage.recryptListKey[i] = htonl(rand[i]);
        temp += rand[i];
        
    }

    for(i = 0; i < 4; i++){
        virage.appStateKey[i] = htonl(rand[i+4]);
        temp += rand[i+4];
        
    }
    
    for(i = 0; i < 4; i++){
        virage.selfMsgKey[i] = htonl(rand[i+8]);
        temp += rand[i+8];
        
    }
    virage.jtagEnable = constantsFile[blobindex];
    temp += ntohl(virage.jtagEnable);
    
    /* compute checksum*/
    virage.csumAdjust = htonl(VIRAGE2_CHECKSUM - ((int)temp));
    
    
    /* serialise the structure 
     */
    index =0;
    for( i =0; i < 5; i++){
        blob[index] = virage.skHash[i];
        index++;
    }
    for(i = 0; i < 16; i++){
        blob[index] = virage.romPatch[i];
        index++;
    }
    for(i = 0; i < sizeof(BbEccPublicKey)/4; i++){
        blob[index] = virage.publicKey[i];
        index++;
    }
    blob[index] = virage.bbId;
    index++;
    for(i =0; i < sizeof(BbEccPrivateKey)/4; i++){
        blob[index] = virage.privateKey[i];
        index++;
    }
    
    for(i =0; i < sizeof(BbAesKey)/4; i++){
        blob[index] = virage.bootAppKey[i];
        
        index++;
    }
    for(i =0; i < sizeof(BbAesKey)/4; i++){
        blob[index] = virage.recryptListKey[i];
        
        index++;
    }
    for(i =0; i < sizeof(BbAesKey)/4; i++){
        blob[index] = virage.appStateKey[i];
        index++;
    }
    
    for(i =0; i < sizeof(BbAesKey)/4; i++){
        blob[index] = virage.selfMsgKey[i];
        index++;
    }

    blob[index] = virage.csumAdjust;
    index++;
    blob[index] = virage.jtagEnable;
    index++;
    
    return 0;
}

/* utility to get words from byte string of 4 bytes 
 */
static u32 get_word(u8 *input){

    return (*(u32 *)input);

}
    
/* allocate for all inputs based on sizes in bbtypes.h and size of certificate
 * blob
 */
int generateUnsignedRSACert(u32 certificateType, u32 sigType, u32 timestamp, u8 *subjectname, u8 * issuername, u32 *publicKey, u32 exponent, u32 *rsacert, int sizeofblob){
    BbRsaCert cert;
    int i, count;

    if(sizeofblob < SIZE_RSA_CERTBLOB_WORDS){
        return -1;
    }
    cert.certId.certType = htonl(certificateType);
    cert.certId.sigType = htonl(sigType);
    cert.certId.date = htonl(timestamp);
    
    memcpy(cert.certId.issuer, issuername, 64);
    memcpy(cert.certId.name.server, subjectname, 16);
    memcpy(cert.publicKey, publicKey, 256);
    cert.exponent = htonl(exponent);

    for(i = 0; i < 128; i++){
        cert.signature.rsa4096[i] = 0;
    }

    /* write to output byte array: see file format defn */
    rsacert[0] = cert.certId.certType;
    rsacert[1] = cert.certId.sigType;
    rsacert[2] = cert.certId.date;
    
    
    count = 3;
    for(i = 0; i < 64; i= i + 4){
        rsacert[count] = get_word(cert.certId.issuer +i);
        count++;
    }

    
/* changed to 64 */
    for(i = 0; i < 16; i = i + 4){
        rsacert[count] = get_word(cert.certId.name.server + i);
        count++;
    }
    for(i = 16; i < 64; i = i+4){
        rsacert[count] = 0;
        count++;
    }
/*
    count = 23;
*/
    
    for(i = 0; i < 64; i++){
        rsacert[count] = htonl(cert.publicKey[i]);
        count++;
    }
/*
    rsacert[87] = cert.exponent;
*/
    rsacert[count] = cert.exponent;
    count++;
    /* overwrite this or entire space below with signature */
/*
    for(i = 88; i< 88+ 64; i++){
*/
    for(i = 0; i < 64; i ++){
        rsacert[count] =0;
        count++;
    }
    
    /* this portion remains zeros for 2048 bit signature */
/*
    for(i = 152; i < 152 + 64; i++){
*/
    for(i = 0; i < 64; i++){
        rsacert[count] = 0;
        count++;
    }
    return 0;
}

    

/* takes private key and other ID data and return cert blob 
 */

int generateUnsignedBbCert(u32 certificateType, 
                           u32 sigType, 
                           u32 timestamp, 
                           u8 * subjectname, 
                           u8 * issuername, 
                           BbEccPrivateKey privatekey, 
                           u32 *ecccert,
                           int sizeofblob){
    
    BbEccCert cert;
    int i;
    BSL_error error;
    BbEccPublicKey publickey;

    if(sizeofblob < SIZE_BB_CERTBLOB_WORDS){
        return -1;
    }

    cert.certId.certType = htonl(certificateType);
    cert.certId.sigType = htonl(sigType);
    cert.certId.date = htonl(timestamp);
    
    memset(cert.certId.issuer, 0, sizeof(BbServerName));
    memset(cert.certId.name.bbid, 0, sizeof(BbName));
    strncpy(cert.certId.issuer, issuername, sizeof(BbServerName));
    strncpy(cert.certId.name.bbid, subjectname, sizeof(BbName));
    
    /* get private key and create public key 
     */
    error = eccGenPublicKey(publickey, privatekey);
   
    if(error != BSL_OK){
        return -1;
    }

    for(i = 0; i < 16; i++){
        cert.publicKey[i] = htonl(publickey[i]);
    }

    memset(&cert.signature, 0, sizeof cert.signature);
    memcpy(ecccert, &cert, sizeof cert);
    return 0;
}
    

/* 
 * create unsigned  meta data blob
 */


/* 
 * create unsigned  meta data blob: called by content publishing 
 */

    
    
int generateUnsignedContentMetaDataHead( 
                                    u32 caCrlVersion,
                                    u32 cpCrlVersion,

                                    BbContentId contentId, 
                                    u32 contentSize, 
                                    u32 descFlags, /* is it common encryption
                                                    use BB_CMD_DESC_COMMON_KEY*/
                                    u8 * commonIv, /* if we want 
                                                      common encryption */
                                    u32 *constantsFile, /* this is to get
                                                           the virage 
                                                           constants file
                                                           and get common key
                                                        */
                                    u8 * contentKey, 
                                    u8 * contentHash,
                                    u8 * contentIv,
                                    /* make this opaque to the server:7 words */
                                    u32 * contentProperties,
                                    /*
                                    u32 execFlags, 
                                    u32 hwAccessRights, 
                                    u32 secureKernelRights,
                                    */

                                    u32 bbid, /* optional to attach to one BB*/
                                    BbContentMetaDataHead *head){
        
    BbAesKey  commonkey;
    u8 encryptResult[BB_CMD_ENCRYPTED_CHUNK_BYTES];
    int err;

    if((contentKey == 0)|| 
       (contentHash == 0)||
       (contentIv == 0)||
       (contentProperties == 0)||
       (head == 0)){
        return -1;
    }

    /* the structure is straightforward, so fill in and return u8 * 
     */
    head->unusedPadding = 0;
    head->caCrlVersion = htonl(caCrlVersion);
    head->cpCrlVersion = htonl(cpCrlVersion);
    
    head->id = htonl(contentId);
    head->size = htonl(contentSize);
    head->descFlags = htonl(descFlags);
 
    memcpy(head->key, contentKey, sizeof head->key);
    memcpy(head->hash, contentHash, sizeof head->hash);
    memcpy(head->iv, contentIv, sizeof head->iv);
    
    head->execFlags = htonl(contentProperties[0]);
    head->hwAccessRights = htonl(contentProperties[1]);
    head->secureKernelRights = htonl(contentProperties[2]);

    head->bbid = htonl(bbid);
/*
    memcpy(head->issuer, issuername, 64);
*/

/* if desc flags says common encryption (example, sysapp) do 
   software aes encrypt using commonIv and commonKey here. 
*/

    if((commonIv ==0) ||(constantsFile ==0)){
        return -1;
    }
    memcpy(head->commonCmdIv, commonIv, sizeof head->commonCmdIv);
    memcpy(commonkey,  &constantsFile[BB_VIRAGE2_BOOTAPPKEY_LOC], sizeof commonkey);
    err = aes_SwEncrypt((u8 *)commonkey, (u8 *)head->commonCmdIv, (u8 *) &(head->key), BB_CMD_ENCRYPTED_CHUNK_BYTES, encryptResult);
    memcpy((u8 *) &(head->key), encryptResult, BB_CMD_ENCRYPTED_CHUNK_BYTES);
    if(err < 0) return err;

    memset(head->contentMetaDataSign, 0, sizeof head->contentMetaDataSign);
    
    return 0;
}
/* from signed content meta data 
 */    

int generateUnsignedEncryptedTicket( BbContentMetaData *metadata,
                                     u32 bbid,
				     BbTicketId tid,
				     u16 limitCode,
				     u16 limit,
                                     u32 tsCrlVersion, 
                                     BbAesIv cmdIv, 
                                     BbEccPrivateKey serverprivateKey,
                                     BbEccPublicKey serverpublicKey,
                                     BbEccPublicKey bbpublicKey,
                                     BbTicket *ticket){
    int i;
    BSL_error err;
    BbAesKey sharedKey;
    int orred = 0;
    u8 encrypted[BB_CMD_ENCRYPTED_CHUNK_BYTES];
    
    memcpy((u8 *)&(ticket->cmd),metadata,sizeof(BbContentMetaData));
    ticket->head.tsCrlVersion = htonl(tsCrlVersion);
    ticket->head.bbId = htonl(bbid);
    ticket->head.tid = htons(tid);
    ticket->head.code = htons(limitCode);
    ticket->head.limit = htons(limit);
    ticket->head.reserved = htons(0);

    for( i = 0; i < 4; i++){
        ticket->head.cmdIv[i] = htonl(cmdIv[i]);
    }
    for( i = 0; i < 16; i++){
        ticket->head.serverKey[i] = htonl(serverpublicKey[i]);
    }
              
    for(i = 0; i < 64; i++){
        ticket->head.ticketSign[i] = 0;
    }

/* from unsigned unencrypted ticket
 * to unsigned encrypted ticket
 * the input private key belongs to the server (ephemeral) and
 * the public key belongs to the requesting BB
 */
    err = eccGenAesKey(bbpublicKey, serverprivateKey, sharedKey);

    if(err != BSL_OK){
        return -1;
    }

    /* encrypt part of Ticket and overwrite in ticketdata
     */
      
    /* encrypt portions that need it. */
    for(i= 0; i < 4; i++){
        sharedKey[i] = htonl(sharedKey[i]);
        /*
        printf("aes key = %08x\n", sharedKey[i]);
        */
    }
    for(i=0; i< 4; i++){
        orred |= sharedKey[i];
    }
    if (orred == 0x00){
        /* computed key is all zero, check input keys */
        return -1;
    }

    if(aes_SwEncrypt((u8 *)sharedKey, (u8 *)ticket->head.cmdIv, (u8 *)ticket->cmd.head.key, BB_CMD_ENCRYPTED_CHUNK_BYTES, encrypted) <0){
        return -1;
    }
    memcpy((u8 *)&(ticket->cmd.head.key), encrypted, BB_CMD_ENCRYPTED_CHUNK_BYTES);
    return 0;

    
}



/* return crl header
 * Add the array of u32 serial numbers.
 * the signature is the first entry in the header.
 * to be added after making this call. 
 * Signature starts from version number, does not include signature
 * field, includes array of serial numbers. 
 * if RSA2048, the sig comes first, zero
 * append to fill. 
 */


int generateCrlHeader(u32 versionNumber, u32 type, u32 unusedArg, u32 date, BbServerName issuer, u32 numberRevoked, u32 sigType, u32 *crlHeaderBlob, u32 *lengthBlob){
    BbCrlHead *crlhead = (BbCrlHead *)crlHeaderBlob;

    crlhead->versionNumber = htonl(versionNumber);
    crlhead->type = htonl(type);
    crlhead->date = htonl(date);
    crlhead->unusedPadding = 0;
    
    memcpy(&crlhead->issuer, issuer, sizeof(BbServerName));
    crlhead->numberRevoked = htonl(numberRevoked);
    crlhead->sigType = htonl(sigType);
    *lengthBlob = sizeof(BbCrlHead);
    
    return 0;
}