/*************************************************************************
* Copyright (C) 2020 Intel Corporation
*
* Licensed under the Apache License,  Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* 	http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law  or agreed  to  in  writing,  software
* distributed under  the License  is  distributed  on  an  "AS IS"  BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the  specific  language  governing  permissions  and
* limitations under the License.
*************************************************************************/

/*!
  *
  *  \file
  *
  *  \brief SMS4 Cipher Block Chaining mode of operation (CBC) example
  *
  *  This example demonstrates usage of SMS4 block cipher
  *  run with CBC mode of operation. Decryption scheme.
  *
  *  The CBC mode of operation is implemented according to the
  *  "NIST Special Publication 800-38A: Recommendation for Block Cipher Modes of
  *  Operation" document:
  *
  *  https://csrc.nist.gov/publications/detail/sp/800-38a/final
  *
  */

#include <string.h>

#include "ippcp.h"
#include "examples_common.h"

/*! SMS4 block size in bytes */
static const int SMS4_BLOCK_SIZE = 16;

/*! Key size in bytes */
static const int KEY_SIZE = 16;

/*! Message size in bytes */
static const int SRC_LEN = 16;

/*! Plain text */
static Ipp8u plainText[SRC_LEN] = {
    0xAA,0xAA,0xAA,0xAA,0xBB,0xBB,0xBB,0xBB,
    0xCC,0xCC,0xCC,0xCC,0xDD,0xDD,0xDD,0xDD
};

/*! Cipher text */
static Ipp8u cipherText[SRC_LEN] = {
    0x78,0xEB,0xB1,0x1C,0xC4,0x0B,0x0A,0x48,
    0x31,0x2A,0xAE,0xB2,0x04,0x02,0x44,0xCB
};

/*! 128-bit secret key */
static Ipp8u key[KEY_SIZE] = {
    0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
    0xFE,0xDC,0xBA,0x98,0x76,0x54,0x32,0x10
};

/*! Initialization vector for CBC mode.
 *  Size of initialization vector for SMS4-CBC shall be equal to the size of SMS4 block (16 bytes).
 */
static Ipp8u iv[SMS4_BLOCK_SIZE] = {
    0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
    0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F
};

/*! Main function  */
int main(void)
{
    /* Size of SMS4 context structure. It will be set up in ippsSMS4GetSize(). */
    int ctxSize = 0;

    Ipp8u pOut[SRC_LEN] = {};

    /* Internal function status */
    IppStatus status = ippStsNoErr;

    /* Pointer to SMS4 context structure */
    IppsSMS4Spec* pSMS4 = 0;

    do {
        /* 1. Get size needed for SMS4 context structure */
        status = ippsSMS4GetSize(&ctxSize);
        if (!checkStatus("ippsSMS4GetSize", ippStsNoErr, status))
            return status;

        /* 2. Allocate memory for SMS4 context structure */
        pSMS4 = (IppsSMS4Spec*)(new Ipp8u[ctxSize]);
        if (NULL == pSMS4) {
            printf("ERROR: Cannot allocate memory (%d bytes) for SMS4 context\n", ctxSize);
            return -1;
        }

        /* 3. Initialize SMS4 context */
        status = ippsSMS4Init(key, sizeof(key), pSMS4, ctxSize);
        if (!checkStatus("ippsSMS4Init", ippStsNoErr, status))
            break;

        /* 4. Decryption */
        status = ippsSMS4DecryptCBC(cipherText, pOut, sizeof(cipherText), pSMS4, iv);
        if (!checkStatus("ippsSMS4DecryptCBC", ippStsNoErr, status))
            break;

        /* Compare decrypted message and reference text */
        if (0 != memcmp(pOut, plainText, sizeof(plainText))) {
            printf("ERROR: Decrypted and reference messages do not match\n");
            break;
        }
    } while (0);

    /* 5. Remove secret and release resources */
    ippsSMS4Init(0, KEY_SIZE, pSMS4, ctxSize);
    if (pSMS4) delete [] (Ipp8u*)pSMS4;

    PRINT_EXAMPLE_STATUS("ippsSMS4DecryptCBC", "SMS4-CBC Decryption", !status)

    return status;
}
