Exemple #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="outbuff"></param>
        /// <param name="inbuff"></param>
        /// <param name="size"></param>
        /// <param name="header"></param>
        /// <returns></returns>
        public void kirk_CMD1_ex(byte *outbuff, byte *inbuff, int size, Aes128CmacHeader *header)
        {
            var bufferBytes = new byte[size];

            fixed(byte *buffer = bufferBytes)
            {
                Crypto.Memcpy(buffer, header, sizeof(Aes128CmacHeader));
                Crypto.Memcpy(buffer + sizeof(Aes128CmacHeader), inbuff, header->DataSize);
                kirk_CMD1(outbuff, buffer, size);
            }
        }
Exemple #2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="outbuff"></param>
        /// <param name="inbuff"></param>
        /// <param name="size"></param>
        /// <param name="generateTrash"></param>
        /// <returns></returns>
        public void kirk_CMD0(byte *outbuff, byte *inbuff, int size, bool generateTrash)
        {
            var cmacHeaderHashBytes = new byte[16];
            var cmacDataHashBytes   = new byte[16];

            fixed(byte *cmacHeaderHash = cmacHeaderHashBytes)
            fixed(byte *cmacDataHash = cmacDataHashBytes)
//#if !USE_DOTNET_CRYPTO
            fixed(Crypto.AesCtx * aesKirk1Ptr = &_aesKirk1)
//#endif
            {
                check_initialized();

                Aes128CmacHeader *header = (Aes128CmacHeader *)outbuff;

                Crypto.Memcpy(outbuff, inbuff, size);

                if (header->Mode != KirkMode.Cmd1)
                {
                    throw(new KirkException(ResultEnum.PspKirkInvalidMode,
                                            $"Expected mode Cmd1 but found {header->Mode}"));
                }

                HeaderKeys *keys = (HeaderKeys *)outbuff; //0-15 AES key, 16-31 CMAC key

                //FILL PREDATA WITH RANDOM DATA
                if (generateTrash)
                {
                    kirk_CMD14(outbuff + sizeof(Aes128CmacHeader), header->DataOffset);
                }

                //Make sure data is 16 aligned
                var chkSize = header->DataSize;

                if ((chkSize % 16) != 0)
                {
                    chkSize += 16 - (chkSize % 16);
                }

                //ENCRYPT DATA
                Crypto.AesCtx k1;
                Crypto.AES_set_key(&k1, keys->Aes, 128);

                Crypto.AES_cbc_encrypt(&k1, inbuff + sizeof(Aes128CmacHeader) + header->DataOffset,
                                       outbuff + sizeof(Aes128CmacHeader) + header->DataOffset, chkSize);

                //CMAC HASHES
                Crypto.AesCtx cmacKey;
                Crypto.AES_set_key(&cmacKey, keys->Cmac, 128);

                Crypto.AES_CMAC(&cmacKey, outbuff + 0x60, 0x30, cmacHeaderHash);

                Crypto.AES_CMAC(&cmacKey, outbuff + 0x60, 0x30 + chkSize + header->DataOffset, cmacDataHash);

                Crypto.Memcpy(header->CmacHeaderHash, cmacHeaderHash, 16);
                Crypto.Memcpy(header->CmacDataHash, cmacDataHash, 16);

                //ENCRYPT KEYS
                Crypto.AES_cbc_encrypt(aesKirk1Ptr, inbuff, outbuff, 16 * 2);
            }
        }