void testHash256()
{
INT32 i;
UINT32 hash[SHA256_HASH_SIZE] = { 0 };
UINT32 data[128] = { 0 };
for (i = 0; i < sizeof(data)/sizeof(data[0]); i++)
{
data[i] = i;
}
if(OK != SHA256Hash((UINT32)data, sizeof(data), hash))
{
print_info("\r\nsha256 err!");
}
else
{
for (i = 0; i < SHA256_HASH_SIZE; i++)
{
print_info_with_u32("\r\n 1: ", hash[i]);
}
}
if(OK != SHA256Hash((UINT32)data, sizeof(data), hash))
{
print_info("\r\nsha256 err!");
}
else
{
for (i = 0; i < SHA256_HASH_SIZE; i++)
{
print_info_with_u32("\r\n 2: ", hash[i]);
}
}
}
/*****************************************************************************
* 函 数 名 : idioIdentify
*
* 功能描述 : 通过校验输入数据的hash值是 否
* 与其签名用RSA解密后的值一样
* 来校验输入数据的合法性 *
*
* 输入参数 : dataAddr--输入数据的地址
* dataLen--输入数据的长度
* pubKey--公钥
* pIdio--输入数据签名的指针
* 输出参数 :
*
* 返 回 值 : OK/ !OK
*
* 其它说明 :
*
*****************************************************************************/
int idioIdentify(UINT32 dataAddr, UINT32 dataLen, KEY_STRUCT *pubKey, UINT32* pIdio)
{
UINT32 sha256Hash[SHA256_HASH_SIZE]; /*用来存放SHA256值的临时buffer*/
UINT32 rsa[IDIO_LEN/4]; /*用来存放RSA加密值的临时buffer*/
int i;
memset(sha256Hash, 0, SHA256_HASH_SIZE*4);
memset(rsa, 0, IDIO_LEN);
/*通过SHA256计算输入数据(data)的hash值*/
if(OK != SHA256Hash(dataAddr, dataLen, sha256Hash))
{
print_info("\r\nhash calc err!" );
return !OK;
}
/*使用公钥(pubKey),通过RSA解密出输入签名(dataIdioAddr)的明文*/
if(OK != RSA(pubKey, pIdio, rsa))
{
print_info("\r\nrsa calc err!" );
return !OK;
}
/*比较二者是否相同*/
for(i = 0; i < SHA256_HASH_SIZE; i++)
{
if( sha256Hash[i] != rsa[i] )
{
return !OK;
}
}
return OK;
}
void Base58::fourbyte_hash256 (void* out, void const* in, std::size_t bytes)
{
unsigned char const* const p (
static_cast <unsigned char const*>(in));
uint256 hash (SHA256Hash (p, p + bytes));
memcpy (out, hash.begin(), 4);
}
bool Base58::decodeWithCheck (const char* psz, Blob& vchRet, Alphabet const& alphabet)
{
if (!decode (psz, vchRet, alphabet))
return false;
if (vchRet.size () < 4)
{
vchRet.clear ();
return false;
}
uint256 hash = SHA256Hash (vchRet.begin (), vchRet.end () - 4);
if (memcmp (&hash, &vchRet.end ()[-4], 4) != 0)
{
vchRet.clear ();
return false;
}
vchRet.resize (vchRet.size () - 4);
return true;
}
/*****************************************************************************
* 函 数 名 : secCheck
*
* 功能描述 : 安全校验总入口
*
* 输入参数 : ulImageAddr--映像地址,必须字对齐
* eImageTye--镜像类型
* 输出参数 :
*
* 返 回 值 : SEC_IMAGE_LEN_ERROR 镜像长度过长
* SEC_EFUSE_READ_ERROR Efuse读取错误
* SEC_EFUSE_NOT_WRITE Efuse未烧写
* SEC_SHA_CALC_ERROR SHA计算错误
* SEC_ROOT_CA_ERROR 根CA校验错误
* SEC_OEMCA_ERROR OEM CA校验错误
* SEC_IMAGE_ERROR 镜像签名校验错误
*
* 其它说明 :
*
*****************************************************************************/
int secCheck(UINT32 ulImageAddr, IMAGE_TYPE_E eImageTye)
{
int i;
UINT32 blLen = 0;
KEY_STRUCT *pstKeyRoot;
KEY_STRUCT *pstKeyBl; /*映像的公钥*/
UINT32 sha256HashCa[SHA256_HASH_SIZE]; /*用来存放SHA256值的临时buffer*/
UINT32 md5HashEfuse[MD5_HASH_SIZE]; /*用来存放SHA256值的MD5值的临时buffer*/
UINT32 md5HashCa[MD5_HASH_SIZE]; /*用来存放SHA256值的MD5值的临时buffer*/
UINT32 imageIdioAddr; /*镜像的签名的地址*/
UINT32 imageCaAddr; /*映像的CA的地址*/
UINT32 imageCaIdioAddr; /*映像的CA签名的地址*/
MD5_CTX md5_contex;
volatile tOcrShareData *pShareData = (tOcrShareData*)M3_SRAM_SHARE_DATA_ADDR;
/*获取bootload.bin文件的长度(字节数)*/
if(IMAGE_TYPE_DOWNLOAD != eImageTye)
{
blLen = *(volatile UINT32 *)(ulImageAddr+BL_LEN_INDEX);
}
else
{
blLen = *(volatile UINT32 *)(ulImageAddr+DOWNLOAD_BL_LEN_INDEX);
}
/* 判断长度是否合法:不为零/字对齐/不翻转/不过大 */
if((0 == blLen)
|| (blLen % 4)
|| (blLen + IDIO_LEN + OEM_CA_LEN + IDIO_LEN < blLen)
|| ((IMAGE_TYPE_DOWNLOAD != eImageTye) /* 若为USB自举版本，无需校验版本长度 */
&& (blLen + IDIO_LEN + OEM_CA_LEN + IDIO_LEN > BOOTLOAD_SIZE_MAX)))
{
print_info_with_u32("\r\nSec image len err: 0x", blLen);
return SEC_IMAGE_LEN_ERROR;
}
/* 获取镜像签名的位置 */
imageIdioAddr = ulImageAddr + blLen;
/* 获取OEM CA的位置 */
imageCaAddr = imageIdioAddr + IDIO_LEN;
/* 获取OEM CA签名的位置 */
imageCaIdioAddr = imageCaAddr + OEM_CA_LEN;
/* 根CA已经在RAM初始化程序中校验通过，加载程序不需再校验根CA */
if(IMAGE_TYPE_DOWNLOAD != eImageTye)
{
/* 读取Efuse中的根CA的Hash值 */
if(OK != efuseRead(EFUSE_GRP_ROOT_CA, md5HashEfuse, MD5_HASH_SIZE))
{
print_info("\r\nEfuse read err!");
return SEC_EFUSE_READ_ERROR;
}
/* 检查Efuse是否已烧写 */
if(EFUSE_NOT_WRITED == efuseWriteCheck(md5HashEfuse, MD5_HASH_SIZE))
{
pShareData->bRootCaInited = FALSE;
pShareData->bSecEn = FALSE; /* Efuse未烧写,无法获得根CA不使能安全校验 */
print_info("\r\nEfuse not write, sec will be disabled!" );
return SEC_EFUSE_NOT_WRITE;
}
pstKeyRoot = (KEY_STRUCT *)(ulImageAddr + ROOT_CA_INDEX);
/* 计算根公钥的Hash值 */
if(OK != SHA256Hash((UINT32)pstKeyRoot, ROOT_CA_LEN, sha256HashCa))
{
print_info("\r\nsha256 err!");
return SEC_SHA_CALC_ERROR;
}
MD5Init(&md5_contex);
MD5Update(&md5_contex, (unsigned char *)sha256HashCa, sizeof(sha256HashCa));
MD5Final(&md5_contex, (unsigned char*)md5HashCa);
/* 比较根公钥的Hash值 */
for(i=0; i<MD5_HASH_SIZE; i++)
{
if(md5HashEfuse[i] != md5HashCa[i])
{
print_info("\r\nRoot CA check err!");
return SEC_ROOT_CA_ERROR;
}
}
/* 保存根公钥，共享给BootLoader */
pShareData->pRootKey = pstKeyRoot;
pShareData->bRootCaInited = TRUE;
}
else
{
/* 防止未运行RAM初始化程序就直接运行USB加载程序 */
if(!pShareData->bRootCaInited)
{
print_info("root ca not inited!");
return SEC_ROOT_CA_ERROR;
}
}
/*鉴权映像证书*/
if(OK != idioIdentify(imageCaAddr, OEM_CA_LEN, pShareData->pRootKey, (UINT32*)imageCaIdioAddr))
{
print_info("\r\nOEM CA check err!" );
return SEC_OEMCA_ERROR;
}
/*鉴权bootload映像*/
pstKeyBl = (KEY_STRUCT *)imageCaAddr;
if(OK != idioIdentify(ulImageAddr, blLen, pstKeyBl, (UINT32*)imageIdioAddr))
{
print_info("\r\nimage check err!" );
return SEC_IMAGE_ERROR;
}
return SEC_SUCCESS;
}
std::string sha256(const std::string &string)
{
return SHA256Hash(string.c_str(), string.length());
}
std::string sha256(const std::string &string)
{
return SHA256Hash(string.c_str(), static_cast<int>(string.length()));
}
void MainWindow::TextChanged(QString text)
{
if(text.isEmpty())
{
this->ui->lineEdit_2->setText("Enter some text");
return;
}
QString str;
switch(this->comboselected)
{
case 0: // MD5
this->ui->lineEdit_2->setText(QString().fromStdString(md5(text.toStdString())));
break;
case 1: // MD4
//this->ui->lineEdit_2->setText();
break;
case 2: // SHA-1
this->ui->lineEdit_2->setText(SHA1Hash(text));
break;
case 3: // SHA-2
//this->ui->lineEdit_2->setText();
break;
case 4: // SHA-3
//this->ui->lineEdit_2->setText();
break;
case 5: // SHA-256
this->ui->lineEdit_2->setText(SHA256Hash(text));
break;
case 6: // SHA-384
//this->ui->lineEdit_2->setText();
break;
case 7: // SHA-512
//this->ui->lineEdit_2->setText();
break;
case 8: // RIPEMD-128
//this->ui->lineEdit_2->setText();
break;
case 9: // RIPEMD-160
//this->ui->lineEdit_2->setText();
break;
case 10: // Whirlpool
//this->ui->lineEdit_2->setText();
break;
case 11: // GOST
//this->ui->lineEdit_2->setText();
break;
case 12: // Tiger
//this->ui->lineEdit_2->setText();
break;
case 13: // Skein
//this->ui->lineEdit_2->setText();
break;
case 14: // Blake
if(BlakeHash(str, text))
this->ui->lineEdit_2->setText(str);
break;
case 15: // NONE
this->ui->lineEdit_2->setText(text);
break;
default:
break;
}
}
