目前主流的IAP 加密算法是什么

logosz · 发表于 2015-12-5 17:09:55

串口IAP，上位机电脑端通过某种加密算法把原始的BIN文件转换（也就是经过运算加密）后，通过串口发送给单片机，单片机将收到的数据先解密，然后再写入自身flash中完成IAP功能。

最近刚涉及到这个内容，大脑完全空白。请过来人给推荐简单有效算法。

最关键的是这个算法在单片机内可以运行，换句话说就是用纯C语言代码可以实现的。不要用什么第三方看不到源码的DLL库等。

mowin · 发表于 2015-12-5 17:13:16

昨天不是有大神放出USB升级源码吗？去看看

logosz · 发表于 2015-12-5 17:20:20

mowin 发表于 2015-12-5 17:13
昨天不是有大神放出USB升级源码吗？去看看

我要的是加密算法，不是升级源码。

823032003 · 发表于 2015-12-5 17:44:11

logosz 发表于 2015-12-5 17:20
我要的是加密算法，不是升级源码。

里面有用AES

mandylion2008 · 发表于 2015-12-5 21:07:14

中国人买东西，还得先学识假防骗；工程师做东西，首先得学会加密而不是具体的开发，难怪老外能做那么多好东西。

ATMEL的应用笔记中有专门将加密通信的，还有源代码，楼主可以参考一下。

myqiang1990 · 发表于 2015-12-5 22:12:21

本帖最后由 myqiang1990 于 2015-12-5 22:22 编辑

我一直用AES。。。。。。。贴上我用的~~也是网上扒的~~修改了一下~~~

/*******************************************************************************
** 文件名: AES.c
** 版本： 1.0
** 工作环境: RealView MDK-ARM 4.23
** 作者: 陈志强
** 生成日期: 2012-4-24
** 功能:
** 相关文件:
** 修改日志：
** 注意事项:
加密算法采用AES ,此加密算法来源于网络
*******************************************************************************/
#include "stm32f10x.h"
#include "aes.h"
#include <string.h>
/*******************************************************************************
*全局变量：
*全局说明:
********************************************************************************/
#define BPOLY 0x1b //!< Lower 8 bits of (x^8+x^4+x^3+x+1), ie. (x^4+x^3+x+1).
#define BLOCKSIZE 16 //4*4矩阵,AES一次只能对16字节加密//!< Block size in number of bytes.
#define KEY_COUNT 3
#if KEY_COUNT == 1
#define KEYBITS 128 //!< Use AES128. 密钥宽度
#elif KEY_COUNT == 2
#define KEYBITS 192 //!< Use AES196.
#elif KEY_COUNT == 3
#define KEYBITS 256 //!< Use AES256.
#else
#error "Use 1, 2 or 3 keys!"
#endif
#if KEYBITS == 128
#define ROUNDS 10 //!< Number of rounds.循环迭代次数
#define KEYLENGTH 16 //!< Key length in number of bytes.
#elif KEYBITS == 192
#define ROUNDS 12 //!< Number of rounds.
#define KEYLENGTH 24 //!< // Key length in number of bytes.
#elif KEYBITS == 256
#define ROUNDS 14 //!< Number of rounds. 循环迭代次数
#define KEYLENGTH 32 //!< Key length in number of bytes.
#else
#error "Key must be 128, 192 or 256 bits!"
#endif
#define EXPANDED_KEY_SIZE (BLOCKSIZE * (ROUNDS+1)) //!< 176, 208 or 240 bytes.
//密钥
unsigned char AES_Key_Table[32] =
{
0x04,0x40,0x04,0x48,0x08,0x58,0x08,0x60,
0x18,0xC0,0x29,0x40,0x4A,0x44,0x08,0x44,
0x09,0x3C,0x01,0x00,0xFF,0xFE,0x01,0x00,
0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00
};
unsigned char block1[256]; //!< Workspace 1.
unsigned char block2[256]; //!< Worksapce 2.
unsigned char tempbuf[256];
unsigned char *powTbl; //!< Final location of exponentiation lookup table.
unsigned char *logTbl; //!< Final location of logarithm lookup table.
unsigned char *sBox; //!< Final location of s-box.
unsigned char *sBoxInv; //!< Final location of inverse s-box.
unsigned char *expandedKey; //!< Final location of expanded key.
void CalcPowLog(unsigned char *powTbl, unsigned char *logTbl)
{
unsigned char i = 0;
unsigned char t = 1;
do {
// Use 0x03 as root for exponentiation and logarithms.
powTbl[i] = t;
logTbl[t] = i;
i++;
// Muliply t by 3 in GF(2^8).
t ^= (t << 1) ^ (t & 0x80 ? BPOLY : 0);
}while( t != 1 ); // Cyclic properties ensure that i < 255.
powTbl[255] = powTbl[0]; // 255 = '-0', 254 = -1, etc.
}
//获取置换S-盒
void CalcSBox( unsigned char * sBox )
{
unsigned char i, rot;
unsigned char temp;
unsigned char result;
// Fill all entries of sBox[].
i = 0;
do {
//Inverse in GF(2^8).
if( i > 0 )
{
temp = powTbl[ 255 - logTbl[i] ];
}
else
{
temp = 0;
}
// Affine transformation in GF(2).
result = temp ^ 0x63; // Start with adding a vector in GF(2).
for( rot = 0; rot < 4; rot++ )
{
// Rotate left.
temp = (temp<<1) | (temp>>7);
// Add rotated byte in GF(2).
result ^= temp;
}
// Put result in table.
sBox[i] = result;
} while( ++i != 0 );
}
//获取解谜替换S盒(用于解密)
void CalcSBoxInv( unsigned char * sBox, unsigned char * sBoxInv )
{
unsigned char i = 0;
unsigned char j = 0;
// Iterate through all elements in sBoxInv using i.
do {
// Search through sBox using j.
do {
// Check if current j is the inverse of current i.
if( sBox[ j ] == i )
{
// If so, set sBoxInc and indicate search finished.
sBoxInv[ i ] = j;
j = 255;
}
} while( ++j != 0 );
} while( ++i != 0 );
}
void CycleLeft( unsigned char * row )
{
// Cycle 4 bytes in an array left once.
unsigned char temp = row[0];
row[0] = row[1];
row[1] = row[2];
row[2] = row[3];
row[3] = temp;
}
//列混合反变换(用于解密)
void InvMixColumn( unsigned char * column )
{
unsigned char r0, r1, r2, r3;
r0 = column[1] ^ column[2] ^ column[3];
r1 = column[0] ^ column[2] ^ column[3];
r2 = column[0] ^ column[1] ^ column[3];
r3 = column[0] ^ column[1] ^ column[2];
column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? BPOLY : 0);
column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? BPOLY : 0);
column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? BPOLY : 0);
column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? BPOLY : 0);
r0 ^= column[0] ^ column[1];
r1 ^= column[1] ^ column[2];
r2 ^= column[2] ^ column[3];
r3 ^= column[0] ^ column[3];
column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? BPOLY : 0);
column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? BPOLY : 0);
column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? BPOLY : 0);
column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? BPOLY : 0);
r0 ^= column[0] ^ column[2];
r1 ^= column[1] ^ column[3];
r2 ^= column[0] ^ column[2];
r3 ^= column[1] ^ column[3];
column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? BPOLY : 0);
column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? BPOLY : 0);
column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? BPOLY : 0);
column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? BPOLY : 0);
column[0] ^= column[1] ^ column[2] ^ column[3];
r0 ^= column[0];
r1 ^= column[0];
r2 ^= column[0];
r3 ^= column[0];
column[0] = r0;
column[1] = r1;
column[2] = r2;
column[3] = r3;
}
//字节替换
void SubBytes( unsigned char * bytes, unsigned char count )
{
do {
*bytes = sBox[ *bytes ]; // Substitute every byte in state.
bytes++;
} while( --count );
}
// 用于解密的字节反替换
void InvSubBytesAndXOR( unsigned char * bytes, unsigned char * key, unsigned char count )
{
do {
// *bytes = sBoxInv[ *bytes ] ^ *key; // Inverse substitute every byte in state and add key.
*bytes = block2[ *bytes ] ^ *key; // Use block2 directly. Increases speed.
bytes++;
key++;
} while( --count );
}
//用于解密的行位移反变换
void InvShiftRows( unsigned char * state )
{
unsigned char temp;
// Note: State is arranged column by column.
// Cycle second row right one time.
temp = state[ 1 + 3*4 ];
state[ 1 + 3*4 ] = state[ 1 + 2*4 ];
state[ 1 + 2*4 ] = state[ 1 + 1*4 ];
state[ 1 + 1*4 ] = state[ 1 + 0*4 ];
state[ 1 + 0*4 ] = temp;
// Cycle third row right two times.
temp = state[ 2 + 0*4 ];
state[ 2 + 0*4 ] = state[ 2 + 2*4 ];
state[ 2 + 2*4 ] = temp;
temp = state[ 2 + 1*4 ];
state[ 2 + 1*4 ] = state[ 2 + 3*4 ];
state[ 2 + 3*4 ] = temp;
// Cycle fourth row right three times, ie. left once.
temp = state[ 3 + 0*4 ];
state[ 3 + 0*4 ] = state[ 3 + 1*4 ];
state[ 3 + 1*4 ] = state[ 3 + 2*4 ];
state[ 3 + 2*4 ] = state[ 3 + 3*4 ];
state[ 3 + 3*4 ] = temp;
}
//用于解密的行混合反变换
void InvMixColumns( unsigned char * state )
{
InvMixColumn( state + 0*4 );
InvMixColumn( state + 1*4 );
InvMixColumn( state + 2*4 );
InvMixColumn( state + 3*4 );
}
void XORBytes( unsigned char * bytes1, unsigned char * bytes2, unsigned char count )
{
do {
*bytes1 ^= *bytes2; // Add in GF(2), ie. XOR.
bytes1++;
bytes2++;
} while( --count );
}
void CopyBytes( unsigned char * to, unsigned char * from, unsigned char count )
{
do {
*to = *from;
to++;
from++;
} while( --count );
}
void KeyExpansion( unsigned char * expandedKey )
{
unsigned char temp[4];
unsigned char i;
unsigned char Rcon[4] = { 0x01, 0x00, 0x00, 0x00 }; // Round constant.
unsigned char * key = AES_Key_Table;//获取我们的密钥,然后生成密钥调度表
// Copy key to start of expanded key.
i = KEYLENGTH;
do {
*expandedKey = (*key)+1; //自己加了1
expandedKey++;
key++;
} while( --i );
// Prepare last 4 bytes of key in temp.
expandedKey -= 4;
temp[0] = *(expandedKey++);
temp[1] = *(expandedKey++);
temp[2] = *(expandedKey++);
temp[3] = *(expandedKey++);
// Expand key.
i = KEYLENGTH;
while( i < BLOCKSIZE*(ROUNDS+1) )
{
// Are we at the start of a multiple of the key size?
if( (i % KEYLENGTH) == 0 )
{
CycleLeft( temp ); // Cycle left once.
SubBytes( temp, 4 ); // Substitute each byte.
XORBytes( temp, Rcon, 4 ); // Add constant in GF(2).
*Rcon = (*Rcon << 1) ^ (*Rcon & 0x80 ? BPOLY : 0);
}
// Keysize larger than 24 bytes, ie. larger that 192 bits?
#if KEYLENGTH > 24
// Are we right past a block size?
else if( (i % KEYLENGTH) == BLOCKSIZE ) {
SubBytes( temp, 4 ); // Substitute each byte.
}
#endif
// Add bytes in GF(2) one KEYLENGTH away.
XORBytes( temp, expandedKey - KEYLENGTH, 4 );
// Copy result to current 4 bytes.
*(expandedKey++) = temp[ 0 ];
*(expandedKey++) = temp[ 1 ];
*(expandedKey++) = temp[ 2 ];
*(expandedKey++) = temp[ 3 ];
i += 4; // Next 4 bytes.
}
}
//解密输入函数
void InvCipher( unsigned char * block, unsigned char * expandedKey )
{
unsigned char round = ROUNDS-1;
expandedKey += BLOCKSIZE * ROUNDS;
XORBytes( block, expandedKey, 16 );
expandedKey -= BLOCKSIZE;
do {
InvShiftRows( block );
InvSubBytesAndXOR( block, expandedKey, 16 );
expandedKey -= BLOCKSIZE;
InvMixColumns( block );
} while( --round );
InvShiftRows( block );
InvSubBytesAndXOR( block, expandedKey, 16 );
}
void aesDecInit(void)
{
powTbl = block1;
logTbl = block2;
CalcPowLog( powTbl, logTbl );
sBox = tempbuf;
CalcSBox( sBox );
expandedKey = block1;
KeyExpansion( expandedKey );
sBoxInv = block2; // Must be block2.
CalcSBoxInv( sBox, sBoxInv );
}
void aesDecrypt( unsigned char * buffer, unsigned char * chainBlock )
{
unsigned char temp[ BLOCKSIZE ];
CopyBytes( temp, buffer, BLOCKSIZE );
InvCipher( buffer, expandedKey );
XORBytes( buffer, chainBlock, BLOCKSIZE );
CopyBytes( chainBlock, temp, BLOCKSIZE );
}
unsigned char Multiply( unsigned char num, unsigned char factor )
{
unsigned char mask = 1;
unsigned char result = 0;
while( mask != 0 )
{
// Check bit of factor given by mask.
if( mask & factor )
{
// Add current multiple of num in GF(2).
result ^= num;
}
// Shift mask to indicate next bit.
mask <<= 1;
// Double num.
num = (num << 1) ^ (num & 0x80 ? BPOLY : 0);
}
return result;
}
unsigned char DotProduct( unsigned char * vector1, unsigned char * vector2 )
{
unsigned char result = 0;
result ^= Multiply( *vector1++, *vector2++ );
result ^= Multiply( *vector1++, *vector2++ );
result ^= Multiply( *vector1++, *vector2++ );
result ^= Multiply( *vector1 , *vector2 );
return result;
}
//行混合变换
void MixColumn( unsigned char * column )
{
unsigned char row[8] = {0x02, 0x03, 0x01, 0x01, 0x02, 0x03, 0x01, 0x01};
// Prepare first row of matrix twice, to eliminate need for cycling.
unsigned char result[4];
// Take dot products of each matrix row and the column vector.
result[0] = DotProduct( row+0, column );
result[1] = DotProduct( row+3, column );
result[2] = DotProduct( row+2, column );
result[3] = DotProduct( row+1, column );
// Copy temporary result to original column.
column[0] = result[0];
column[1] = result[1];
column[2] = result[2];
column[3] = result[3];
}
void MixColumns( unsigned char * state )
{
MixColumn( state + 0*4 );
MixColumn( state + 1*4 );
MixColumn( state + 2*4 );
MixColumn( state + 3*4 );
}
//行位移变换
void ShiftRows( unsigned char * state )
{
unsigned char temp;
// Note: State is arranged column by column.
// Cycle second row left one time.
temp = state[ 1 + 0*4 ];
state[ 1 + 0*4 ] = state[ 1 + 1*4 ];
state[ 1 + 1*4 ] = state[ 1 + 2*4 ];
state[ 1 + 2*4 ] = state[ 1 + 3*4 ];
state[ 1 + 3*4 ] = temp;
// Cycle third row left two times.
temp = state[ 2 + 0*4 ];
state[ 2 + 0*4 ] = state[ 2 + 2*4 ];
state[ 2 + 2*4 ] = temp;
temp = state[ 2 + 1*4 ];
state[ 2 + 1*4 ] = state[ 2 + 3*4 ];
state[ 2 + 3*4 ] = temp;
// Cycle fourth row left three times, ie. right once.
temp = state[ 3 + 3*4 ];
state[ 3 + 3*4 ] = state[ 3 + 2*4 ];
state[ 3 + 2*4 ] = state[ 3 + 1*4 ];
state[ 3 + 1*4 ] = state[ 3 + 0*4 ];
state[ 3 + 0*4 ] = temp;
}
//加密输入函数
void Cipher( unsigned char * block, unsigned char * expandedKey )
{
unsigned char round = ROUNDS-1;
XORBytes( block, expandedKey, 16 );
expandedKey += BLOCKSIZE;
do {
SubBytes( block, 16 );//字节替换
ShiftRows( block ); //行位移变换
MixColumns( block ); //行混合变换
XORBytes( block, expandedKey, 16 );
expandedKey += BLOCKSIZE;
} while( --round );//对明文进行14次迭代加密
SubBytes( block, 16 );
ShiftRows( block );
XORBytes( block, expandedKey, 16 );
}
void aesEncInit(void)
{
powTbl = block1;
logTbl = tempbuf;
CalcPowLog( powTbl, logTbl );
sBox = block2;
CalcSBox( sBox );//获取SBOX
expandedKey = block1;
KeyExpansion( expandedKey );//获取密钥扩展历程(密钥调度表)
}
void aesEncrypt( unsigned char * buffer, unsigned char * chainBlock )
{
XORBytes( buffer, chainBlock, BLOCKSIZE );//用密钥调度表对明文块一个一个字节异或!
Cipher( buffer, expandedKey );//获取密码
CopyBytes( chainBlock, buffer, BLOCKSIZE );//将密码输出
}
//加密
void AES_Enc(unsigned char *buffer)
{
unsigned char chainCipherBlock[16];
memset(chainCipherBlock,0x00,sizeof(chainCipherBlock));
//aesEncInit();/* 在执行加密初始化之前可以为AES_Key_Table赋值有效的密码数据 */
aesEncrypt(buffer, chainCipherBlock);/* AES加密，数组dat里面的新内容就是加密后的数据。 */
}
//解密
void AES_Dec(unsigned char *buffer)
{
unsigned char chainCipherBlock[16];
memset(chainCipherBlock,0x00,sizeof(chainCipherBlock));/* 这里要重新初始化清空 */
//aesEncInit();
aesDecrypt(buffer, chainCipherBlock);/* AES解密，密文数据存放在dat里面，经解密就能得到之前的明文。 */
}

复制代码

myqiang1990 · 发表于 2015-12-5 22:20:14

网上收藏到的好东西~~~

vjcmain · 发表于 2015-12-5 22:58:55

myqiang1990 发表于 2015-12-5 22:20
网上收藏到的好东西~~~

谢谢你分享的资料

sdram · 发表于 2015-12-6 09:00:01

不知道主流是什么,我用的是AES128.

chenaiguo0503 · 发表于 2015-12-6 09:17:20

如果不是太复杂，就可以用DES和AES轻量级的加密算法，但是如果芯片硬件不支持的话，用软件去处理，会占用太多的处理时间

aaabbbad · 发表于 2015-12-6 16:05:54

myqiang1990 发表于 2015-12-5 22:20
网上收藏到的好东西~~~

谢谢您的分享，先收藏等有时间了学些下

huangqi412 · 发表于 2015-12-7 09:36:08

myqiang1990 发表于 2015-12-5 22:20
网上收藏到的好东西~~~

收藏大礼包了

wkman · 发表于 2015-12-7 10:41:51

不明觉厉，，，

lllaaa · 发表于 2015-12-7 11:30:19

xxtea也很轻量级

ghostxdy · 发表于 2015-12-7 13:18:39

myqiang1990 发表于 2015-12-5 22:20
网上收藏到的好东西~~~

谢谢大礼包！

vivi_cq1982 · 发表于 2015-12-8 00:28:09

myqiang1990 发表于 2015-12-5 22:20
网上收藏到的好东西~~~

谢谢你的大礼包

ttoto · 发表于 2015-12-8 01:34:32

别人加密都想着非主流。。。

yixuanyuxiao · 发表于 2015-12-8 20:04:46

aes加密 mark

yylwt · 发表于 2015-12-9 10:30:30

谢谢大礼包，AES是主流啊

单飞 · 发表于 2015-12-9 10:58:08

正需要。。。

hanshiruo · 发表于 2016-1-8 10:59:16

AES 几号

windancerhxw · 发表于 2016-1-11 21:05:00

mark一下

jxyctwt · 发表于 2016-1-15 21:02:06

我之前做的用25X16做了给U盘的样子的专用板做升级 ,其实只做了每个字节取反操作....

peterlzj · 发表于 2016-1-15 23:11:28

mark, 有用，多谢分享

晚枫 · 发表于 2016-1-19 15:34:25

myqiang1990 发表于 2015-12-5 22:20
网上收藏到的好东西~~~

谢谢分享。你是用软件处理AES128的还是硬件自带AES128处理的呢？

用M3内核的ARM不知道用软件法处理AES128速度怎么样。

magicoctoier1 · 发表于 2016-1-19 20:43:01

一直使用STM32的那个加密库

renjun_EMbest · 发表于 2016-1-19 21:01:16

AES128或者256

信仰在空中飘扬 · 发表于 2016-1-19 22:33:00

magicoctoier1 发表于 2016-1-19 20:43
一直使用STM32的那个加密库

我还不知道STM32有自带加密库、、可以给个官方库的下载链接吗？

myqiang1990 · 发表于 2016-1-20 14:11:44

晚枫发表于 2016-1-19 15:34
谢谢分享。你是用软件处理AES128的还是硬件自带AES128处理的呢？

用M3内核的ARM不知道用软件法处理AES12 ...

软件处理的~我现在一直在用，很好用啊~用在很多地方~速度很快啊~真的~

zhcj66 · 发表于 2016-1-20 14:24:21

myqiang1990 发表于 2015-12-5 22:20
网上收藏到的好东西~~~

好东西谢谢分享

sjh18256 · 发表于 2016-1-20 14:54:19

关注下，也在搞这方面的东西。

monkey.liu · 发表于 2016-1-20 20:46:35

谢谢分享加密算法。

慢慢懂 · 发表于 2016-1-21 13:05:36

首先谢谢分享，弱弱问下bin文档只是一个二进制码了，已经不可以泄露什么信息了吧，为啥还需要费劲去加密？求砖头拍醒

canspider · 发表于 2016-1-21 13:31:49

慢慢懂发表于 2016-1-21 13:05
首先谢谢分享，弱弱问下bin文档只是一个二进制码了，已经不可以泄露什么信息了吧，为啥还需要费劲去加密？ ...

站在信息论的角度
这个二进制和你的源代码是等效的，他们熵一样
加密就是为了改变他的熵，和源代码不一样

njwanglei · 发表于 2016-1-25 11:07:57

MARK，需要学习的真的提多，感觉现在自己最求的就是一个完善的体系

sywong · 发表于 2016-2-24 22:32:43

myqiang1990 发表于 2015-12-5 22:12
我一直用AES。。。。。。。贴上我用的~~也是网上扒的~~修改了一下~~~

感謝分享。

dcl_yufeimen · 发表于 2016-2-24 23:02:13

谢谢分享

qq78929709 · 发表于 2016-2-25 13:45:26

MARK一下

孤星云影 · 发表于 2016-2-25 15:27:12

ST官方加密库。官方地址（收费）：http://www.st.com/web/catalog/to ... 961/SS1743/PF259409
下载：
官方已经好久没更新了，不过也够用了。

kinsno · 发表于 2016-3-4 13:09:15

myqiang1990 发表于 2016-1-20 14:11
软件处理的~我现在一直在用，很好用啊~用在很多地方~速度很快啊~真的~

主要用哪几个函数！来个示范例子？

whow · 发表于 2016-3-4 20:47:39

收藏7楼加密算法

stevenh · 发表于 2016-3-27 00:11:49

谢谢分享！！

gzhua20088ssj · 发表于 2016-9-5 21:55:25

传说中的MD5好像无人能破解，不知是否这样呢

shangdawei · 发表于 2016-9-5 22:56:04

gzhua20088ssj 发表于 2016-9-5 21:55
传说中的MD5好像无人能破解，不知是否这样呢

这个是单向的，好像不能用。

shangdawei · 发表于 2016-9-5 22:56:33

酷贴！3DES、AES、RC6、TEA、RSA、MD5、SHA1、SHA256加密源码大聚齐
http://www.amobbs.com/thread-5466438-1-1.html
(出处: amoBBS 阿莫电子论坛)

isakura · 发表于 2016-9-5 23:13:41

为什么不可以自己随便定义一个加密算法？应该也很难被算出来吧

shangdawei · 发表于 2016-9-5 23:39:10

http://www.libtom.net/?page=feat ... &whatfile=crypt

LibTomCrypt

Ciphers Supported.
Blowfish
XTEA
RC5
RC6
SAFER+
Rijndael (aka AES)
Twofish
SAFER (K64, SK64, K128, SK128)
RC2
DES, 3DES
CAST5
Noekeon
Skipjack
Anubis (with optional tweak as proposed by the developers)
Khazad
KASUMI
SEED

vtte · 发表于 2016-9-6 07:52:52

用的AES256

suebillt · 发表于 2016-9-6 11:05:41

vtte 发表于 2016-9-6 07:52
用的AES256

我有一个疑问，用加密算法加密然后下载到MCU解密，那么存在MCU内部的还是正确的二进制代码。
有心人只要用JLINK把相关地址的代码读出来即可？

lhaoyue · 发表于 2016-9-6 13:25:03

AES 加密算法

shangdawei · 发表于 2016-9-6 13:52:55

suebillt 发表于 2016-9-6 11:05
我有一个疑问，用加密算法加密然后下载到MCU解密，那么存在MCU内部的还是正确的二进制代码。
有心人只要 ...

前提是可以用JLINK把相关地址的代码读出来。

suebillt · 发表于 2016-9-6 15:25:09

shangdawei 发表于 2016-9-6 13:52
前提是可以用JLINK把相关地址的代码读出来。

可以直接读全部的ROM

shangdawei · 发表于 2016-9-6 17:22:45

suebillt 发表于 2016-9-6 15:25
可以直接读全部的ROM

如果这样，加密就没有意义了。

ycping · 发表于 2016-9-6 18:24:26

标记一下。

qwe2231695 · 发表于 2016-9-6 22:13:45

suebillt 发表于 2016-9-6 15:25
可以直接读全部的ROM

启用了读取保护的单片机是不能读的，并且关闭JTAGE SWD，除非先进行全片擦除。

Alien5 · 发表于 2019-7-13 14:51:30

mark一下,今后用得着

billtian · 发表于 2019-10-16 09:11:59

IAP 加密

diego2003 · 发表于 2019-10-28 17:01:27

AES加密算法 MARK

zhuyuye · 发表于 2019-10-28 18:51:42

myqiang1990 发表于 2015-12-5 22:20
网上收藏到的好东西~~~

感谢分享，谢谢

cl1cl1cl1cl1 · 发表于 2019-12-15 08:28:10

AES加密，谢谢大礼包。

Edesigner. · 发表于 2019-12-18 17:37:39

不用那么复杂，以4字节为单位，移位一下就行。IAP程序里还原

gsq19920418 · 发表于 2020-3-9 12:36:04

孤星云影发表于 2016-2-25 15:27
ST官方加密库。官方地址（收费）：http://www.st.com/web/catalog/tools/FM147/CL1794/SC961/SS1743/PF2594 ...

支不支持HAL库呢？看着好像有标准库

孤星云影 · 发表于 2020-3-17 16:49:18

gsq19920418 发表于 2020-3-9 12:36
支不支持HAL库呢？看着好像有标准库

应该不支持，毕竟这么多年没更新了……

gsq19920418 · 发表于 2020-3-17 20:53:15

孤星云影发表于 2020-3-17 16:49
应该不支持，毕竟这么多年没更新了……

支持，改名了 X-Cube

bwang1 · 发表于 2020-8-30 11:59:06

Edesigner. 发表于 2019-12-18 17:37
不用那么复杂，以4字节为单位，移位一下就行。IAP程序里还原

移位是个快速处理的办法,具体是怎么操作呢,请指定一二

Edesigner. · 发表于 2020-8-30 12:02:34

bwang1 发表于 2020-8-30 11:59
移位是个快速处理的办法,具体是怎么操作呢,请指定一二

4字节32个位，你可以左移右移，也可以取反，异或。反正能还原就行。

bwang1 · 发表于 2020-8-31 10:50:32

Edesigner. 发表于 2020-8-30 12:02
4字节32个位，你可以左移右移，也可以取反，异或。反正能还原就行。

嗯嗯,明白了O(∩_∩)O哈哈~

jjj · 发表于 2020-8-31 11:49:40

对称：AES
非对称:RSA
二选一

目前主流的IAP 加密算法是什么

阿莫论坛20周年了！感谢大家的支持与爱护！！

本帖子中包含更多资源

本帖子中包含更多资源