ST-link v2 readout protection (RDP) 설정

Embedded/펌웨어? 2022. 12. 5. 21:14

한번씩 STM칩을 만지는데

그때마다 flash 읽기 방지를 까먹는다ㅋㅋ;

 

 

아래 그림에 Read Out Protection을 설정하면

Flash 읽기를 방지할 수 있다.

Level 0 : 읽기, 쓰기 모두 가능

Level 1 : 쓰기 가능, 읽기 불가능

Level 2 : 모두 불가능

 

Level 2는 돌이킬 수 없기에 매우매우 고심하여 셋팅해야 한다

특별한 경우 아니면 Level 1만 해도 충분하지 않을까 싶다ㅋ

 

 

자료를 찾아보니 저걸 뚫고 해킹하는 것들도 있던데....

다음에 또 기회가 되면 해봐야겠다ㅋ

 

'Embedded > 펌웨어?' 카테고리의 다른 글

USBISP-MK2 Manual  (0) 2020.06.16
C 예제) AES-128 ECB  (1) 2019.06.10
stm32f05xx CRC  (0) 2019.04.16

설정

트랙백

댓글

USBISP-MK2 Manual

Embedded/펌웨어? 2020. 6. 16. 11:30

--- 모드별 핀사양

 

 

 

 

--- USBISP MK2 Supported Devices

 

<ISP Mode>

ATmega1280 ATmega1281 ATmega1284P ATmega1284 ATmega128A ATmega128RFA1 ATmega128 ATmega162 ATmega164A ATmega164PA ATmega164P ATmega165A ATmega165PA ATmega165P ATmega168A ATmega168PA ATmega168P ATmega168 ATmega169A ATmega169PA ATmega169P ATmega16A ATmega16HVBrevB ATmega16HVB ATmega16M1 ATmega16U2 ATmega16U4 ATmega16 ATmega2560 ATmega2561 ATmega324A ATmega324PA ATmega324P ATmega3250A ATmega3250P ATmega3250 ATmega325A ATmega325P ATmega325 ATmega328P ATmega328 ATmega3290P ATmega3290 ATmega329A ATmega329PA ATmega329P ATmega329 ATmega32A ATmega32C1 ATmega32HVBrevB ATmega32HVB ATmega32M1 ATmega32U2 ATmega32U4 ATmega32 ATmega48A ATmega48PA ATmega48P ATmega48 ATmega640 ATmega644A ATmega644PA ATmega644P ATmega644 ATmega6450A ATmega6450P ATmega6450 ATmega645A ATmega645P ATmega645 ATmega6490A ATmega6490P ATmega6490 ATmega649A ATmega649P ATmega649 ATmega64A ATmega64C1 ATmega64M1 ATmega64 ATmega8515 ATmega8535 ATmega88A ATmega88PA ATmega88P ATmega88 ATmega8A ATmega8U2 ATmega8 ATtiny13A ATtiny13 ATtiny1634 ATtiny167 ATtiny2313A ATtiny2313 ATtiny24A ATtiny24 ATtiny25 ATtiny261A ATtiny261 ATtiny26 ATtiny4313 ATtiny43U ATtiny44A ATtiny44 ATtiny45 ATtiny461A ATtiny461 ATtiny48 ATtiny828 ATtiny84A ATtiny84 ATtiny85 ATtiny861A ATtiny87 ATtiny88 AT90CAN128 AT90CAN32 AT90CAN64 AT90PWM161 AT90PWM1 AT90PWM216 AT90PWM2B AT90PWM316 AT90PWM3B AT90PWM81 AT90USB1286 AT90USB1287 AT90USB162 AT90USB646 AT90USB647 AT90USB82 ATA6285 ATA6286

 

<PDI Mode>

ATxmega128A1U ATxmega128A1 ATxmega128A3U ATxmega128A3 ATxmega128A4U ATxmega128B1 ATxmega128B3 ATxmega128C3 ATxmega128D3 ATxmega128D4 ATxmega16A4U ATxmega16A4 ATxmega16C4 ATxmega16D4 ATxmega192A3U ATxmega192A3 ATxmega192C3 ATxmega192D3 ATxmega256A3BU ATxmega256A3B ATxmega256A3U ATxmega256A3 ATxmega256C3 ATxmega256D3 ATxmega32A4U ATxmega32A4 ATxmega32C4 ATxmega32D4 ATxmega384C3 ATxmega384D3 ATxmega64A1U ATxmega64A1 ATxmega64A3U ATxmega64A3 ATxmega64A4U ATxmega64B1 ATxmega64B3 ATxmega64C3 ATxmega64D3 ATxmegaD4

 

<TPI Mode>

ATtiny4 ATtiny5 ATtiny9 ATtiny10 ATtiny20 ATtiny40

 

USBISP_MK2_manual.pdf
0.64MB

'Embedded > 펌웨어?' 카테고리의 다른 글

ST-link v2 readout protection (RDP) 설정  (0) 2022.12.05
C 예제) AES-128 ECB  (1) 2019.06.10
stm32f05xx CRC  (0) 2019.04.16

설정

트랙백

댓글

C 예제) AES-128 ECB

Embedded/펌웨어? 2019. 6. 10. 16:47

아래 예제 소스이다.

 

메인에서

Data1 배열을 함수

AES_ECB_Encrypt(Data1, Key, EncBuff, Len); 

를 사용하여 암호화 된 데이터가 EncBuff에 저장되고

 

암호화된 데이터를 함수
AES_ECB_Decrypt(EncBuff, Key, DecBuff, Len); 

를 사용하면 DecBuff에 데이터가 나온다.

 

CBC 방식에 암호화 복호화 키 값은 좀 더 찾아봐야겠다.

 

 

예제)

// 여기부터 쭉 그냥 복사 시작 ------------------------------------------------------

#include  <stdio.h>
#include  <string.h>

#ifdef AES256
#define KEYLEN      32
#elif defined(AES192)
#define KEYLEN      24
#else
#define KEYLEN      16  //Key Length in unsigned chars
#endif

#define Nr          (KEYLEN/8+3)*2      //The number of rounds in AES Cipher.
#define KEYEXPSIZE  (Nr+1)*16
#define BLOCKLEN    16

#define SWAP(T,A,B)         {T=A; A=B; B=T;}
#define ROTATE(T,A,B,C,D)   {T=A; A=B; B=C; C=D; D=T;}


static const unsigned char SBox[256]=
{
    //0     1    2      3     4    5     6     7      8    9     A      B    C     D     E     F
    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
};


static const unsigned char SBoxInvert[256]=
{
    0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
    0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
    0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
    0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
    0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
    0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
    0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
    0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
    0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
    0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
    0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
    0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
    0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
    0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
    0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
    0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
};




//-----------------------------------------------------------------------------
//The lookup-tables are marked CONST so they can be placed in read-only storage instead of RAM
//The numbers below can be computed dynamically trading ROM for RAM -
//This can be useful in (embedded) bootloader applications, where ROM is often limited.
//-----------------------------------------------------------------------------
void GetSBox(unsigned char * TA)
{
    TA[0]=SBox[TA[0]];
    TA[1]=SBox[TA[1]];
    TA[2]=SBox[TA[2]];
    TA[3]=SBox[TA[3]];
}




//This function produces 4*(Nr+1) round keys. The round keys are used in each round to decrypt the states.
void KeyExpansion(unsigned char * ExpKey, unsigned char * Key)
{
    int I, T;
    unsigned char TA[4];                 //Used for the column/row operations
    static const unsigned char Rcon[11]= //The round constant word array, Rcon[I], contains the values given by X to th e power (I-1) being powers of X (X is denoted as {02}) in the field GF(2^8)
    {
        0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36
    };

    memcpy(ExpKey, Key, KEYLEN);

    //All other round keys are found from the previous round keys.
    for (I=KEYLEN; I<KEYEXPSIZE; I+=4)
    {
        memcpy(TA, ExpKey+I-4, 4);

        if (I % KEYLEN==0)
        {
            T=TA[0];
            TA[0]=TA[1];
            TA[1]=TA[2];
            TA[2]=TA[3];
            TA[3]=T;

            GetSBox(TA);

            TA[0]^=Rcon[I/KEYLEN];
        }
        #if defined(AES256)
        if (I % KEYLEN==16) GetSBox(TA);
        #endif
        ExpKey[I+0]=ExpKey[I-KEYLEN+0]^TA[0];
        ExpKey[I+1]=ExpKey[I-KEYLEN+1]^TA[1];
        ExpKey[I+2]=ExpKey[I-KEYLEN+2]^TA[2];
        ExpKey[I+3]=ExpKey[I-KEYLEN+3]^TA[3];
    }
}



//This function adds the round key to state.
//The round key is added to the state by an XOR function.
void AddRoundKey(unsigned char (*State)[4], unsigned char* ExpKey, unsigned char Round)
{
    int I, J;

    for (I=0; I<4; I++)
        for (J=0; J<4; J++) State[I][J]^=ExpKey[Round*4*4 + I*4 + J];
}



//The SubBytes Function Substitutes the values in the state matrix with values in an S-box.
void SubBytes(unsigned char (*State)[4])
{
    int I;

    for (I=0; I<4; I++) GetSBox(State[I]);
}



//The ShiftRows() function shifts the rows in the state to the left.
//Each row is shifted with different offset.
//Offset = Row number. So the first row is not shifted.
void ShiftRows(unsigned char (*State)[4])
{
    unsigned char T;

    ROTATE(T, State[0][1], State[1][1], State[2][1], State[3][1]);

    SWAP(T, State[0][2], State[2][2]);
    SWAP(T, State[1][2], State[3][2]);

    ROTATE(T, State[0][3], State[3][3], State[2][3], State[1][3]);
}



void InvShiftRows(unsigned char (*State)[4])
{
    unsigned char T;

    ROTATE(T, State[3][1], State[2][1], State[1][1], State[0][1]);

    SWAP(T, State[0][2], State[2][2]);
    SWAP(T, State[1][2], State[3][2]);

    ROTATE(T, State[0][3], State[1][3], State[2][3], State[3][3]);
}




int XTime(int X)
{
    return ((X<<1) & 0xFF) ^ (((X>>7)&1)*0x1B);
}



//MixColumns function mixes the columns of the state matrix
void MixColumns(unsigned char (*State)[4])
{
    int I, T1, T2;

    for (I=0; I<4; I++)
    {
        T1=State[I][0];
        T2=State[I][0]^State[I][1]^State[I][2]^State[I][3];
        State[I][0]^=XTime(State[I][0]^State[I][1])^T2;
        State[I][1]^=XTime(State[I][1]^State[I][2])^T2;
        State[I][2]^=XTime(State[I][2]^State[I][3])^T2;
        State[I][3]^=XTime(State[I][3]^T1)^T2;
    }
}



//Used to multiply numbers in the field GF(2^8)
int Multiply(int X, int Y)
{
    return ((Y>>0&1)*X)^
           ((Y>>1&1)*XTime(X))^
           ((Y>>2&1)*XTime(XTime(X)))^
           ((Y>>3&1)*XTime(XTime(XTime(X))))^
           ((Y>>4&1)*XTime(XTime(XTime(XTime(X)))));
}


//MixColumns function mixes the columns of the state matrix.
//The method used to multiply may be difficult to understand for the inexperienced.
//Please use the references to gain more information.
void InvMixColumns(unsigned char (*State)[4])
{
    int  I, A, B, C, D;

    for (I=0; I<4; I++)
    {
        A=State[I][0];
        B=State[I][1];
        C=State[I][2];
        D=State[I][3];

        State[I][0] = Multiply(A, 0x0E) ^ Multiply(B, 0x0B) ^ Multiply(C, 0x0D) ^ Multiply(D, 0x09);
        State[I][1] = Multiply(A, 0x09) ^ Multiply(B, 0x0E) ^ Multiply(C, 0x0B) ^ Multiply(D, 0x0D);
        State[I][2] = Multiply(A, 0x0D) ^ Multiply(B, 0x09) ^ Multiply(C, 0x0E) ^ Multiply(D, 0x0B);
        State[I][3] = Multiply(A, 0x0B) ^ Multiply(B, 0x0D) ^ Multiply(C, 0x09) ^ Multiply(D, 0x0E);
    }
}




//The SubBytes Function Substitutes the values in the state matrix with values in an S-box.
void InvSubBytes(unsigned char (*State)[4])
{
    int I, J;

    for (I=0; I<4; I++)
        for (J=0; J<4; J++) State[J][I]=SBoxInvert[State[J][I]];
}



void Cipher(unsigned char (*State)[4], unsigned char * ExpKey)
{
    int Round;

    //Add the First round key to the state before starting the rounds.
    AddRoundKey(State, ExpKey, 0);

    //There will be Nr rounds.
    //The first Nr-1 rounds are identical.
    //These Nr-1 rounds are executed in the loop below.
    for (Round=1; Round<Nr; Round++)
        {
        SubBytes(State);
        ShiftRows(State);
        MixColumns(State);
        AddRoundKey(State, ExpKey, Round);
        }

    //The last round is given below.
    //The MixColumns function is not here in the last round.
    SubBytes(State);
    ShiftRows(State);
    AddRoundKey(State, ExpKey, Nr);
}



void InvCipher(unsigned char (*State)[4], unsigned char* ExpKey)
{
    int Round;

    //Add the First round key to the state before starting the rounds.
    AddRoundKey(State, ExpKey, Nr);

    //There will be Nr rounds.
    //The first Nr-1 rounds are identical.
    //These Nr-1 rounds are executed in the loop below.
    for (Round=Nr-1; Round>0; Round--)
        {
        InvShiftRows(State);
        InvSubBytes(State);
        AddRoundKey(State, ExpKey, Round);
        InvMixColumns(State);
        }

    //The last round is given below.
    //The MixColumns function is not here in the last round.
    InvShiftRows(State);
    InvSubBytes(State);
    AddRoundKey(State, ExpKey, 0);
}



//-----------------------------------------------------------------------------
//          ECB
//-----------------------------------------------------------------------------
void AES_ECB_Encrypt(unsigned char * Input, unsigned char * Key, unsigned char * Output, int Length)
{
    unsigned char ExpKey[KEYEXPSIZE];

    memcpy(Output, Input, Length);
    KeyExpansion(ExpKey, Key);
    Cipher((unsigned char (*)[4])Output, ExpKey);
}


void AES_ECB_Decrypt(unsigned char* Input, unsigned char* Key, unsigned char* Output, int Length)
{
    unsigned char ExpKey[KEYEXPSIZE];

    memcpy(Output, Input, Length);
    KeyExpansion(ExpKey, Key);
    InvCipher((unsigned char (*)[4])Output, ExpKey);
}



//-----------------------------------------------------------------------------
//          CBC
//-----------------------------------------------------------------------------
void XorWithIv(unsigned char * Buff, unsigned char * Iv)
{
    int I;
    for (I=0; I<BLOCKLEN; I++) Buff[I]^=Iv[I];
}


void AES_CBC_Encrypt(unsigned char * Output, unsigned char * Input, int Length, unsigned char * Key, unsigned char * Iv)
{
    int I, Extra;
    unsigned char ExpKey[KEYEXPSIZE];

    Extra=Length % BLOCKLEN;
    KeyExpansion(ExpKey, Key);

    for (I=0; I<Length; I+=BLOCKLEN)
        {
        XorWithIv(Input, Iv);
        memcpy(Output, Input, BLOCKLEN);
        Cipher((unsigned char (*)[4])Output, ExpKey);
        Iv=Output;
        Input+=BLOCKLEN;
        Output+=BLOCKLEN;
        }

    if (Extra)
        {
        memcpy(Output, Input, Extra);
        Cipher((unsigned char (*)[4])Output, ExpKey);
        }
}


void AES_CBC_Decrypt(unsigned char * Output, unsigned char * Input, int Length, unsigned char * Key, unsigned char * Iv)
{
    int I, Extra;
    unsigned char ExpKey[KEYEXPSIZE];

    Extra=Length % BLOCKLEN;
    KeyExpansion(ExpKey, Key);

    for (I=0; I<Length; I+=BLOCKLEN)
        {
        memcpy(Output, Input, BLOCKLEN);
        InvCipher((unsigned char (*)[4])Output, ExpKey);
        XorWithIv(Output, Iv);
        Iv=Input;
        Input+=BLOCKLEN;
        Output+=BLOCKLEN;
        }

    if (Extra)
        {
        memcpy(Output, Input, Extra);
        InvCipher((unsigned char (*)[4])Output, ExpKey);
        }
}

// 여기까지 쭉 복사 끝 --------------------------------------------------------------


// 여기부터 메인 예제 ---------------------------------------------------------------

int main(int argc, char *argv[]) {
    int  I, Len;
    unsigned char Data[]={0x00, 0x0A, 0x11, 0x45, 0xEE, 0x90, 0xEE, 0x92, 0xEE, 0x91, 0x00, 0xF1, 0x21, 0xAA, 0x03, 0xFF};
    unsigned char Data1[]={0x00, 0x0A, 0x12, 0x44, 0xEE, 0x90, 0xEE, 0x92, 0xEE, 0x91, 0x00, 0x91, 0x34, 0x1A, 0xBB, 0xFF};
    unsigned char Data2[]={0x00, 0x0A, 0x13, 0x64, 0xEE, 0x90, 0xEE, 0x92, 0xEE, 0x91, 0x00, 0x84, 0x01, 0x1C, 0xC1, 0xFF};
    unsigned char Key[]={0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x47, 0x77, 0x11, 0x1E, 0x3c};
    unsigned char EncBuff[80];
    unsigned char DecBuff[80];
 
    printf("Testing AES128\n\n");
 
    Len = 16;
 
    // Hex 출력
    printf("Hex     :  ");
    for(I=0; I<Len; I++) printf("%02X ", Data[I]);
    
    // 암호화
    AES_ECB_Encrypt(Data, Key, EncBuff, Len);
    printf("\nEncorded: ");
    for (I=0; I<Len; I++) printf(" %02X", EncBuff[I]);
 
    // 복호화
    memset(DecBuff, 0, sizeof(DecBuff));
    AES_ECB_Decrypt(EncBuff, Key, DecBuff, Len);
    printf("\nDecorded:  ");
    for(I=0; I<Len; I++) printf("%02X ", DecBuff[I]);
printf("\n----------------------------------------------------------\n");


    // Hex 출력
    printf("Hex     :  ");
    for(I=0; I<Len; I++) printf("%02X ", Data1[I]);
    
    // 암호화
    AES_ECB_Encrypt(Data1, Key, EncBuff, Len);
    printf("\nEncorded: ");
    for (I=0; I<Len; I++) printf(" %02X", EncBuff[I]);
 
    // 복호화
    memset(DecBuff, 0, sizeof(DecBuff));
    AES_ECB_Decrypt(EncBuff, Key, DecBuff, Len);
    printf("\nDecorded:  ");
    for(I=0; I<Len; I++) printf("%02X ", DecBuff[I]);
printf("\n----------------------------------------------------------\n");


    // Hex 출력
    printf("Hex     :  ");
    for(I=0; I<Len; I++) printf("%02X ", Data2[I]);
    AES_ECB_Encrypt(Data2, Key, EncBuff, Len);
 
    // 암호화
    printf("\nEncorded: ");
    for (I=0; I<Len; I++) printf(" %02X", EncBuff[I]);
 
    // 복호화
    memset(DecBuff, 0, sizeof(DecBuff));
    AES_ECB_Decrypt(EncBuff, Key, DecBuff, Len);
    printf("\nDecorded:  ");
    for(I=0; I<Len; I++) printf("%02X ", DecBuff[I]);
printf("\n----------------------------------------------------------\n");
 
    return 0;

}

 

 

실행 화면

 

main.c
0.01MB

 

 

확인 사이트

http://aes.online-domain-tools.com/

 

AES Encryption – Easily encrypt or decrypt strings or files

Input text: (plain)

aes.online-domain-tools.com

'Embedded > 펌웨어?' 카테고리의 다른 글

ST-link v2 readout protection (RDP) 설정  (0) 2022.12.05
USBISP-MK2 Manual  (0) 2020.06.16
stm32f05xx CRC  (0) 2019.04.16

설정

트랙백

댓글

stm32f05xx CRC

Embedded/펌웨어? 2019. 4. 16. 14:12

내부 CRC 사용

CRC32/MPEG-2 방식

 

소스)

 

- 함수

uint32_t crc_compute(uint32_t * start_addr, uint32_t size)

{

    uint32_t crc_code;

    uint32_t i = 0;

 

    // Enable CRC

    __HAL_RCC_CRC_CLK_ENABLE();

 

    CRC->CR |= CRC_CR_RESET;

 

    while(i < size)

    {

        CRC->DR = start_addr[i];

        i++;

    }

 

    crc_code = CRC->DR;

 

    // Disable CRC

    __HAL_RCC_CRC_CLK_DISABLE();

 

    return crc_code;

}

 

 

- 사용

    uint32_t tbuf[2] = {0x1A2B3C4D, 0x1A2B3C4D};

 

    tempp = crc_compute(&tbuf, 2);

 

 

    -->tempp = 0xF7461111

 

 

 

https://crccalc.com/

'Embedded > 펌웨어?' 카테고리의 다른 글

ST-link v2 readout protection (RDP) 설정  (0) 2022.12.05
USBISP-MK2 Manual  (0) 2020.06.16
C 예제) AES-128 ECB  (1) 2019.06.10

설정

트랙백

댓글