Ynt: Tutsak yazilim felsefesi - Cipe Uzaktan kod yuklemek

Başlatan z, 26 Nisan 2014, 17:40:16

z

@ghs

Dedim ya bazi bilesenleri gizli. Merak eden sistemimi yaptigimda kirabiliyorsa kirar yada kirdirir.

Bu gizliliğe ragmen  devre semalarimi yayinlayacagim.

Neyse onemli olan bu değil. Soruma odaklanalim. Sonucta ortalikta ciddi bir teknik problem var.

Ustelik ne demistim?

ST firmasi L,  CM2,  CM4 serilerinde buna engel olacak mekanizmayi cip icinde donanimsal olarak kurmus.

Yani bu sorun sadece benim karsilastigim bir sorun değil. Bazi musterilerine cozum olsun diye bu cozumu sunmus.
Bana e^st de diyebilirsiniz.   www.cncdesigner.com

X-Fi

Hocam ZIOS kurulu olan sistemde kullanıcının debug yapabilme imkanı olacak mı?

Not: L serisini cortex serilerinden ayırmayınız. CM3 veya CM0 işlemcisini kullanıyor.
http://www.coskunergan.com/    (Yürümekle varılmaz, lakin varanlar yürüyenlerdir.)

z

Evet CM3 serisinin L tipinde bu koruma varken L serisi olmayan CM3lere  bu özellik konmamış. O yüzden ayırıma gittim.

ZIOS kurulu sistemlerde malesef JTAG vs üzerinden debug yapılamıyor. ST bunu engelliyor.

Bana e^st de diyebilirsiniz.   www.cncdesigner.com

z

Askeri cihazların korunmaya ihtiyacı hem var hem yok.

Askeri cihazlar askeri bir bölgede zaten. Her isteyen elini kolunu sallayarak içeri giremez bu sistemlere erişemez. Her isteyen de kartlarını incelemk için askeri cihazı satın alamaz. Neyse boşverin askeri işleri.

Benim yapmak istediğim iş belli.

Çipime benim uzaktan yerleştireceğim kodlarımı kimse bilmesin.
Çipime isteyen kendi programını yükleyebilsin.
Çipime program yükleyen çipin içindeki gizli alanlara ulaşamasın.

Bu teknik sorunu tartışmak istiyorum. Boş verin gerisini.

Bana e^st de diyebilirsiniz.   www.cncdesigner.com

t2


Belki fikir verir, benzerini yapabilirsiniz.
http://www.tracesystemsinc.com/sums/sums-overview.html

Alıntı

       
  • No programming needed - ready to use
  • No need to recompile your own Main App code to work with our bootloader - use it as is!
  • Simple, automated mode for your non-technical End Users
  • Powerful Developer Mode for you & your technical and factory users
  • BRAND it yourself - customize company name and logo image with NO PC Programming At All.
  • Sends your firmware in an encrypted file that protects your intellectual property

       
  • Protects against programming your firmware into the wrong device, or an unauthorized device

       
  • Automatically collects files together, zips them up into a WinZip archive, customizes a cover letter, and emails it all to your customer!  All in about 20 seconds.
  • The system grows with your product line - when you develop a product with a different processor, just buy a new bootloader from us for that processor and connectivity type.  Your new bootloader installs right into the SUMS system, ready to work for just those of your products that need it.
  • Serial Number (known to both Bootloader Firmware and your Main App Firmware) allows you to charge your customers for new versions or new firmware "personalities" that work in your product. Opens up whole new revenue streams for your company!

z

Ext Ram kullanmak istemiyorum zaten islemcim de buna musait degil. MPU unitesinden nasil yararlanabilirim?

Bugune kadar hic MPU kullanmadim. Neler yapilabilir bilmiyorum.

Amacimi sadelestirip anlatayim.

Flashin ilk 2K lik bolumu CPU tarafindan sadece kod isletmek amaciyla okunsun ama bir islemci komutu ile bu alandaki herhangi bir adres okunamasin. MPU bana bu konuda yardimci olabilirmi?
Bana e^st de diyebilirsiniz.   www.cncdesigner.com

z

Incelemek gerekecek

/******************** (C) COPYRIGHT 2011 xx Design House ***********************
* File Name          : serial_comms.h
* Author             : LGE
* Version            : V1.0.0
* Date               : 8/2/2011
* Description        : Header for serial_comms.c module
*******************************************************************************/
 
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __MEMPROT_H
#define __MEMPROT_H
 
/* Includes ------------------------------------------------------------------*/
#include "stm32f10x.h"
/* Exported types ------------------------------------------------------------*/
/* Exported constants --------------------------------------------------------*/
/* Exported macro ------------------------------------------------------------*/
/* Exported functions ------------------------------------------------------- */
void InitMemProt(void);
void SimulateMemoryViolation(void);
/* Exported interrupt handlers ---------------------------------------------- */
void EH_MemoryViolation(void);
void SetupMemoryViolationCommandPending(void);
bool IsMemoryViolationCommandPending(void);
 
#endif /* __MEMPROT_H */
 
/******************* (C) xx Design House *****END OF FILE****/
 

memprot.c

/******************** (C) xx Design House **************************************
* File Name          : memprot.c
* Author             : LGE
* Version            : V1.0.0
* Date               : 8/2/2011
* Description        : Demonstrate MPU (Memory Protection Unit) feature
*******************************************************************************/
 
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "core_cm3.h"
#include "stm32f10x_mpu.h"
#include "memprot.h"
 
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
//The size (in bytes of the protected buffer).
#define SIZEOF_PROTMEM        0x4000            //16kB; min 256, must be a power of 2
 
/* Private variables ---------------------------------------------------------*/
static bool bMemoryViolationCommandPending FALSE;
 
#define ADDRESS_OF_PROTECTED_SRAM   (SRAM_BASE + 0x14000)
volatile __root __no_init u32 au32MyProtectedBuffer[SIZEOF_PROTMEM/sizeof(u32)] @ ADDRESS_OF_PROTECTED_SRAM;
 
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
 
/*******************************************************************************
* Function Name  : InitMemProt
* Description    : Initialise memory-protection demonstration.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void InitMemProt(void)
{
#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1)
      
MPU_RegionInit_TypeDef sMPUInit;
 
      
//Disable MPU
      
MPU_Disable();
 
      
//Turn off all regions - the reset states for the ENA bits are undefined.
     
for(u32 u32Rgn=u32Rgn < ((MPU->TYPE&MPU_TYPE_DREGION_Msk) >> MPU_TYPE_DREGION_Pos) ; u32Rgn++)
      {
            
MPU->RNR  MPU_RNR_REGION_Msk & (u32Rgn << MPU_RNR_REGION_Pos);
            
MPU->RASR 0;
      };
 
#if 0  //Not tested.
      //
    // Configure an executable, read-only MPU region for flash.  It is a 1MB
    // region. This region is needed so that the program can execute from
    // flash.
    //
      
sMPUInit.regionEnable TRUE;
      
sMPUInit.regionNo 0;
      
sMPUInit.baseAddress FLASH_BASE;
      
sMPUInit.size mpuRegionSize1Mb;
      
sMPUInit.accessPermission mpuRegionApPRo_URo;
      
sMPUInit.disableExec FALSE;
      
sMPUInit.shareable FALSE;
      
sMPUInit.cacheable TRUE;
      
sMPUInit.bufferable TRUE;
      
sMPUInit.srd 0x00;
      
sMPUInit.tex 0;
      
MPU_ConfigureRegion(&sMPUInit);
 
    
//
    // Configure a read-write MPU region for RAM.  It is a 128kB KB region.  There
    // are the two top 16kB sub-regions disabled to achieve the 96kB of RAM
      // which is available in the microcontroller.  We are also going to disable
      // top top region of the 96kB, to demonstrate illegal access in the application.
    //
      
sMPUInit.regionEnable TRUE;
      
sMPUInit.regionNo 1;
      
sMPUInit.baseAddress SRAM_BASE;
      
sMPUInit.size mpuRegionSize128Kb;
      
sMPUInit.accessPermission mpuRegionApFullAccess;
      
sMPUInit.disableExec TRUE;
      
sMPUInit.shareable FALSE;
      
sMPUInit.cacheable TRUE;
      
sMPUInit.bufferable TRUE;
      
sMPUInit.srd 0xC0 0x20;         //only 96kB RAM, not 128kB.
      
sMPUInit.tex 0;
      
MPU_ConfigureRegion(&sMPUInit);
#endif
     
      //
    // Configure a read-only MPU region for the 16 KB of RAM that is disabled in
    // the previous region.  This region is used for demonstrating read-only
    // permissions.
    //
      
sMPUInit.regionEnable TRUE;
      
sMPUInit.regionNo 2;
      
sMPUInit.baseAddress ADDRESS_OF_PROTECTED_SRAM;
      
sMPUInit.size mpuRegionSize16Kb;
      
sMPUInit.accessPermission mpuRegionNoAccess;
      
sMPUInit.disableExec TRUE;
      
sMPUInit.shareable FALSE;
      
sMPUInit.cacheable TRUE;
      
sMPUInit.bufferable TRUE;
      
sMPUInit.srd 0x00;
      
sMPUInit.tex 0;
      
MPU_ConfigureRegion(&sMPUInit);
 
#if 0 //Not tested.
    //
    // Configure a read-write MPU region for peripherals.  The region is 512 kB
    // total size, with several sub-regions disabled to prevent access to areas
    // where there are no peripherals.  This region is needed because the
    // program needs access to some peripherals.
    //
      
sMPUInit.regionEnable TRUE;
      
sMPUInit.regionNo 3;
      
sMPUInit.baseAddress PERIPH_BASE;
      
sMPUInit.size mpuRegionSize512Mb;
      
sMPUInit.accessPermission mpuRegionApFullAccess;
      
sMPUInit.disableExec TRUE;
      
sMPUInit.shareable TRUE;
      
sMPUInit.cacheable FALSE;
      
sMPUInit.bufferable TRUE;
      
sMPUInit.srd 0x00;
      
sMPUInit.tex 0;
      
MPU_ConfigureRegion(&sMPUInit);
 
    
//
    // Configure a read-write MPU region for access to the NVIC.  The region is
    // 4 KB in size.  This region is needed because NVIC registers are needed
    // in order to control the MPU.
    //
      
sMPUInit.regionEnable TRUE;
      
sMPUInit.regionNo 4;
      
sMPUInit.baseAddress ITM_BASE;
      
sMPUInit.size mpuRegionSize1Mb;
      
sMPUInit.accessPermission mpuRegionApFullAccess;
      
sMPUInit.disableExec TRUE;
      
sMPUInit.shareable TRUE;
      
sMPUInit.cacheable FALSE;
      
sMPUInit.bufferable TRUE;
      
sMPUInit.srd 0x00;
      
sMPUInit.tex 0;
      
MPU_ConfigureRegion(&sMPUInit);
#endif
     
      //Enable the Memory Manage Handler */
      
NVIC_SystemHandlerPriorityConfig(SystemHandler_MemoryManage28);    
      
NVIC_SystemHandlerConfig(SystemHandler_MemoryManageENABLE);
     
      
//Enable memory protection and mem fault exceptions
      
MPU_Enable(MPU_CTRL_ENABLE_Msk MPU_CTRL_PRIVDEFENA_Msk);
 
#endif //defined (__MPU_PRESENT) && (__MPU_PRESENT == 1)
}
 
/*******************************************************************************
* Function Name  : SetupMemoryViolationCommandPending
*     This is required, since the command parser is handled in interrupt time,
*     but the MPU must be tripped from the mainline, otherwise a 'hard fault'
*     is generated.
* Description    : Sets up to trip the MPU.
* Input          : None.
* Output         : None.
* Return         : None.
*******************************************************************************/
void SetupMemoryViolationCommandPending(void)
{
      
bMemoryViolationCommandPending TRUE;
}
 
/*******************************************************************************
* Function Name  : IsMemoryViolationCommandPending
* Description    : Returns true is there was a command to trip the MPU.
* Input          : None.
* Output         : None
* Return         : Bool - true if an MPU trip command received.
*******************************************************************************/
bool IsMemoryViolationCommandPending(void)
{
      return 
bMemoryViolationCommandPending;
}
 
/*******************************************************************************
* Function Name  : SimulateMemoryViolation
* Description    : Write something to a protected memory area.
* Input          : None.
* Output         : None
* Return         : None
*******************************************************************************/
void SimulateMemoryViolation(void)
{
      
//DO NOT CHANGE THIS FUNCTION UNLESS YOU ALSO CHANGE THE EH_MemoryViolation()
      //EXCEPTION HANDLER.
      
bMemoryViolationCommandPending FALSE;
 
      
//Access the forbidden memory!
      
au32MyProtectedBuffer[0] = 0x12345678;
}
 
/******************************************************************************/
/*                 Memory Protection Exception Handlers                  */
/*  See Interrupt Handler stubs in system_stm32f10x.c.  These functions are   */
/*  interrupt-time handlers called by the interrupt stub.                             */
/******************************************************************************/
 
/*******************************************************************************
* Function Name  : EH_MemoryViolation - EXCEPTION HANDLER - KEEP SHORT
* Description    : This function handles MPU exceptions.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void EH_MemoryViolation(void)
{
      
volatile auto u16 au16Stack[1];
     
      
//WARNING! THIS FUNCTION PERFORMS A WRITE ON AN OUT_OF_ARRAY LOCATION.
      //IT MODIFIES THE STACK POP VALUE FOR PC, SO PC SKIPS THE INSTRUCTION
      //WHICH CAUSES THE MPU VIOLATION.  Otherwise application endlessly loops
      //at MPU violation/re-do violation instruction.  The stack modification
      //increments the PC by 2 to skip the violating instruction ("STR R1, [R0]").
      //If changing the SimulateMemoryViolation() function body, then be sure to
      //update this handler to skip the MPU violation instruction(s).
      
au16Stack[16] += 2;
     
      
//Write a 1 to the MEM FAULT flag to clear it
      
SCB->SHCSR |= SCB_SHCSR_MEMFAULTACT;     
 
      
//Go to infinite loop when Memory Manage exception occurs
      
SetScreen_MPU_Error();
}
 
/******************* (C) COPYRIGHT 2011 xx Design House ********END OF FILE****/
 

stm32f10x_mpu.h

 
/******************** (C) xx Design House **************************************
* File Name          : stm32f10x_MPU.h
* Author             : LGE
*     ported from http://cdn.energymicro.com/dl/documentation/doxygen/efm32__mpu_8h-source.html
* Version            : V1.0.0
* Date               : 8/2/2011
* Description        : MPU Access library
*******************************************************************************/
 
/***************************************************************************/
#ifndef __STM32F10X_MPU_H
#define __STM32F10X_MPU_H
 
#include "intrinsics.h"
#include "stm32f10x.h"
#include "cortexm3_macro.h"
 
#if defined(__MPU_PRESENT) && (__MPU_PRESENT == 1)
 
#ifdef __cplusplus
extern "C" {
#endif
 
/***************************************************************************/
/***************************************************************************/
#define MPU_CTRL_PRIVDEFENA    MPU_CTRL_PRIVDEFENA_Msk
 
#define MPU_CTRL_HFNMIENA      MPU_CTRL_HFNMIENA_Msk
 
/*******************************************************************************
 ********************************   ENUMS   ************************************
 ******************************************************************************/
 
typedef enum
{
      
mpuRegionSize32b   4,
      
mpuRegionSize64b   5,
      
mpuRegionSize128b  6,
      
mpuRegionSize256b  7,
      
mpuRegionSize512b  8,
      
mpuRegionSize1Kb   9,
      
mpuRegionSize2Kb   10,
      
mpuRegionSize4Kb   11,
      
mpuRegionSize8Kb   12,
      
mpuRegionSize16Kb  13,
      
mpuRegionSize32Kb  14,
      
mpuRegionSize64Kb  15,
      
mpuRegionSize128Kb 16,
      
mpuRegionSize256Kb 17,
      
mpuRegionSize512Kb 18,
      
mpuRegionSize1Mb   19,
      
mpuRegionSize2Mb   20,
      
mpuRegionSize4Mb   21,
      
mpuRegionSize8Mb   22,
      
mpuRegionSize16Mb  23,
      
mpuRegionSize32Mb  24,
      
mpuRegionSize64Mb  25,
      
mpuRegionSize128Mb 26,
      
mpuRegionSize256Mb 27,
      
mpuRegionSize512Mb 28,
      
mpuRegionSize1Gb   29,
      
mpuRegionSize2Gb   30,
      
mpuRegionSize4Gb   31
MPU_RegionSize_TypeDef;
 
typedef enum
{
      
mpuRegionNoAccess     0,
      
mpuRegionApPRw        1,
      
mpuRegionApPRwURo     2,
      
mpuRegionApFullAccess 3,
      
mpuRegionApPRo        5,
      
mpuRegionApPRo_URo    6
MPU_RegionAp_TypeDef;
 
 
/*******************************************************************************
 *******************************   STRUCTS   ***********************************
 ******************************************************************************/
 
typedef struct
{
      
bool                   regionEnable;
      
uint8_t                regionNo;
      
uint32_t               baseAddress;
      
MPU_RegionSize_TypeDef size;
      
MPU_RegionAp_TypeDef   accessPermission;
      
bool                   disableExec;
      
bool                   shareable;
      
bool                   cacheable;
      
bool                   bufferable;
      
uint8_t                srd;
      
uint8_t                tex;
MPU_RegionInit_TypeDef;
 
#define MPU_INIT_FLASH_DEFAULT                                  \
{                                                             \
      
true,                   /* Enable MPU region.            */ \
      
0,                      /* MPU Region number.            */ \
      
FLASH_MEM_BASE,         /* Flash base address.           */ \
      
mpuRegionSize1Mb,       /* Size - Set to max for XL device */ \
      
mpuRegionApFullAccess,  /* Access permissions.           */ \
      
false,                  /* Execution allowed.            */ \
      
false,                  /* Not shareable.                */ \
      
true,                   /* Cacheable.                    */ \
      
false,                  /* Not bufferable.               */ \
      
0,                      /* No subregions.                */ \
      
0                       /* No TEX attributes.            */ \
}
 
 
#define MPU_INIT_SRAM_DEFAULT                                 \
{                                                             \
      
true,                   /* Enable MPU region.            */ \
      
1,                      /* MPU Region number.            */ \
      
RAM_MEM_BASE,           /* SRAM base address.            */ \
      
mpuRegionSize128Kb,     /* Size - Set to max. for XL devices. */ \
      
mpuRegionApFullAccess,  /* Access permissions.           */ \
      
false,                  /* Execution allowed.            */ \
      
true,                   /* Shareable.                    */ \
      
true,                   /* Cacheable.                    */ \
      
false,                  /* Not bufferable.               */ \
      
0,                      /* No subregions.                */ \
      
0                       /* No TEX attributes.            */ \
}
 
 
#define MPU_INIT_PERIPHERAL_DEFAULT                             \
{                                                             \
      
true,                   /* Enable MPU region.            */ \
      
0,                      /* MPU Region number.            */ \
      
0,                      /* Region base address.          */ \
      
mpuRegionSize32b,       /* Size - Set to minimum         */ \
      
mpuRegionApFullAccess,  /* Access permissions.           */ \
      
true,                   /* Execution not allowed.        */ \
      
true,                   /* Shareable.                    */ \
      
false,                  /* Not cacheable.                */ \
      
true,                   /* Bufferable.                   */ \
      
0,                      /* No subregions.                */ \
      
0                       /* No TEX attributes.            */ \
}
 
 
/*******************************************************************************
 *****************************   PROTOTYPES   **********************************
 ******************************************************************************/
 
 
void MPU_ConfigureRegion(MPU_RegionInit_TypeDef *init);
 
 
/***************************************************************************/
#pragma inline = forced
void MPU_Disable(void)
{
      
SCB->SHCSR &= ~SCB_SHCSR_MEMFAULTENA_Msk;      /* Disable fault exceptions */
      
MPU->CTRL  &= ~MPU_CTRL_ENABLE_Msk;            /* Disable the MPU */
}
 
/***************************************************************************/
#pragma inline = forced
void MPU_Enable(uint32_t flags)
{
      
assert_param(!(flags & ~(MPU_CTRL_PRIVDEFENA_Msk |
                          
MPU_CTRL_HFNMIENA_Msk |
                          
MPU_CTRL_ENABLE_Msk)));
 
      
MPU->CTRL   flags MPU_CTRL_ENABLE_Msk;     //Enable the MPU
      
SCB->SHCSR &= ~SCB_SHCSR_MEMFAULTACT;                 //clear any fault flag
      
SCB->SHCSR |= SCB_SHCSR_MEMFAULTENA_Msk;        //Enable fault exceptions
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* defined(__MPU_PRESENT) && (__MPU_PRESENT == 1) */
 
#endif /* __STM32F10X_MPU_H */
 

stm32f10x_mpu.c

/******************** (C) xx Design House **************************************
* File Name          : stm32f10x_MPU.c
* Author             : LGE
*     ported from http://cdn.energymicro.com/dl/documentation/doxygen/efm32__mpu_8h-source.html
* Version            : V1.0.0
* Date               : 8/2/2011
* Description        : MPU Access library
*******************************************************************************/
#include "stm32f10x_mpu.h"
 
 
/*******************************************************************************
 **************************   GLOBAL FUNCTIONS   *******************************
 ******************************************************************************/
 
 
/***************************************************************************/
void MPU_ConfigureRegion(MPU_RegionInit_TypeDef *init)
{
      
assert_param(init->regionNo < ((MPU->TYPE MPU_TYPE_DREGION_Msk) >>
                                
MPU_TYPE_DREGION_Pos));
 
      
MPU->RNR init->regionNo;
 
      if (
init->regionEnable)
      {
            
assert_param(!(init->baseAddress MPU_RBAR_ADDR_Msk));
            
assert_param(init->tex <= 0x7);
 
            
MPU->RBAR init->baseAddress;
            
MPU->RASR = ((init->disableExec 0) << MPU_RASR_XN_Pos)   |
                              (
init->accessPermission      << MPU_RASR_AP_Pos)   |
                              (
init->tex                   << MPU_RASR_TEX_Pos)  |
                              ((
init->shareable   0) << MPU_RASR_S_Pos)    |
                              ((
init->cacheable   0) << MPU_RASR_C_Pos)    |
                              ((
init->bufferable  0) << MPU_RASR_B_Pos)    |
                              (
init->srd                   << MPU_RASR_SRD_Pos)  |
                              (
init->size                  << MPU_RASR_SIZE_Pos) |
                              (
1                           << MPU_RASR_ENA_Pos);
      }
      else
      {
            
MPU->RBAR 0;
            
MPU->RASR 0;
      };
}
Bana e^st de diyebilirsiniz.   www.cncdesigner.com

emrahmrcn

Merhaba,
Konsept olarak MPU ne yapar ne eder biliyorum, ama bir türlü kullanmak nasip olmadı. Bende Z nin teknik isteklerini elbirliği ile çözebileceğimize inanıyorum vede bu başlığın işletim sistemleri mimarisi açısından güzel bir kaynak olacağını umut ediyorum.
Öncelikle MPU kullanarak bir kod parçacığını nasıl yasaklı hale getirebiliriz bunun örneğini görmek çok isterim,
Benim yaradılışımda bir ayrıcalık varsa o da TÜRK olmamdır. M.K ATATÜRK

z

@emrahmrcn

Ansiklopedik bilgi de olsa MPU hakkında bildiklerini yazarmısın? Registerlerine baktım neyseki fazla değil. Bu yakınlarda MPU ile çalışmaya başlayacağım fakat şu anda konuya çok uzağım.

Bu arada bu kadar korumaya gerek yok diyen arkadaşlara;

Bir kart yaptınız. Bu kartın içine kullanıcıların yazılım atmasına da izin vereceksiniz diyelim. Bu kart için PC yazılımları da geliştireceğinizi düşünün. Yani kartınız PC ile de etkileşimli çalışacak.

Eğer kartınız kolayca kopyalanırsa yazdığınız PC yazılımları da kopya kartlar üzerinde çalışacak demektir.

Kartınızı kullanarak ticari ürünler geliştirmek istiyorsanız bazı korumalar yapmak kadar normal bir şey olamaz.

İllaki karta yüklenen programların yüksek teknolojiler, askeri uygulama yazılımları, güçlü algoritmalar olması gerekmez.

Eğer ki karta üretim aşamasında kod yükleyip bir daha da bu kodları değiştirmeyecek olsaydım sadece okuma koruması ve JTAG yasağı yeterli olurdu. Fakat proje tanımına bakarsanız olayın çok daha karmaşık olduğunu görülecektir.


Bana e^st de diyebilirsiniz.   www.cncdesigner.com

hgs

Mcunun hafızasında belli kısımları güncelleyebilirsiniz. Bunuda pc yazılımınızla  entegre olarak yapabilirsiniz. Üretim bilgileri ile alakalı bir sayfayı hiç bir zaman güncelletmezsiniz.

Donanımsal koruma yöntemleri mevcut. Kart üzerinde konulabilecek ek donanımlar ile bir takım düzenekler kurulabilir. Bu düzeneklerin dogru çalışmadığı kartların kopyalanması mümkün olmaz.

Daha pek çok yöntem ortaya konabilir...


Ama ben hala korumanın bu kadar abartılmasına gerek olmadıgı kanısındayım. Fikir iyi ise ürün satar. Kar marjı iyi ise parası olan herhangi bir kişi benzer kartı tasarlayabilir tasarlatabilir. Devrede koruma yaparak fikri koruyamazsınız.

z

CM3 islemcinin MPU unitesinin olusu ve kodlarin user ve privileged olmak uzere iki seviyede yazilabiliyor olmasi ARM islemcileri oyuncak islemcilerden ayiran en buyuk ozellik.

Islemcinin 32 bit olmasi, icinde ivir zivir cevre biriminin hatta NVIC unitesinin olmasi hikayeymis. Ayni isleri yuksek hizli 8 bit oyuncaklarla da yapabiliyoruz ve bugun farkettim ki yillardir CM3'u oyuncak islemci gibi kullaniyormusum.

ARM islemciyi hakkiyla kullanmaya daha bu gun basladim. (30-4-2014)

Sebep ne peki? Elbette MPU + 2 seviyede kodlamaya gecis.


Bana e^st de diyebilirsiniz.   www.cncdesigner.com

X-Fi

BEnim aklıma şöyle bir yol geldi;

Sizin bir aes tablonuz ve çözücü programınız olsun bunu memory e yazın MPU ile bu kodların bulundugu sektörü veya sektörleri saklayın. Ürün sizden çıkarken burası yazılı olsun.

1-Kullanıcı işlemciye sizin daimi yazılımınızın kriptolu opcodunu istediği boot yolunu kullanarak boş adreslerine yazsın.

2-Daha sonra içeride var olan kripto çözücü dahili programı çözüp MPU ile tüm programı saklasın.

Bu işlemler tekrarlanması gerektiğinde kripto çözücü kısım dahili programı silip boş sektörlerin korumalarını kaldırsın işlemler 1. maddeden devam etsin.

http://www.coskunergan.com/    (Yürümekle varılmaz, lakin varanlar yürüyenlerdir.)

z

Soyle bir risk varsa hic isime gelmez.

Dusundugum sistemde isletim sistemi asla silinmeyecek. Disaridan program yuklenirken;

Oldu ya, hatali program bile yuklense,
Oldu ya kripto yanlis bile acilsa,
Oldu ya flash programlanirken elektrik bile kesilse,
Oldu ya cip tam programlanirken kilitlense,

Cip tekrar programi yukleyebilmeli.

Bu hayati bir nokta. Aksi takdirde isletim sistemi goctu diye cipin/kartin postayla vs bana ulastirilmasi gerekir.
Bana e^st de diyebilirsiniz.   www.cncdesigner.com

z

Hocam yapmak istedigim ise odaklaniliyor ve elestiriler hep bunun gereksizligi uzerine. Halbuki amac isten cok daha cazip degilmi?

Siradan programlamanin otesine gecmek gerekiyor.
Bana e^st de diyebilirsiniz.   www.cncdesigner.com

Burak B

"Perfect is the enemy of good" Voltaire

     Bence para-zaman olarak bakıldığında yapmak istediğiniz mantıksız bir durum oluşturuyor. Ancak sizin pozisyonunuzda bu geçerli değil diye düşünüyorum. Çünkü nasılsa bir geliriniz söz konusu ve bu yaptığınız cihazı piyasaya çıkarmak için bir "deadline, çalışan maaşı, v.b." sıkıntınız yok. Diğer yandan dimağen Ar&Ge birikimi olarak değerli bir konu. Ancak konunun kendisinin ürünün işlevinden daha alametli ve değerli oluşu marjinal bir ironi ortaya koyuyor.

     Bakın @gerbay DSO Quad' ın firmware yapısına ilişkin bir grafik paylaşmış. Bu şekilde geliştirilecek uygulamaya ait sistemin sınıflandırılması ve katmanlara ayrılması, daha sonrada bu katmanlar arası ilişkilerin kurallara bağlanması ile elde edilecek modüler bir yapı istediğinizi size fazlasıyla sunacaktır.

    Ayrıca koruma konusunda bu denli bir paranoya yapmanın bir anlamı yok. Simetrik ve Asimetrik kriptolama yöntemlerinin ve Hash algortimalarının doğru kullanımını bilmek pek çok konuda size yeterli güvenliği sağlar.

   Yukarıda yaptığım alıntı oldukça önemli bir cümledir. Unutmayın kusursuz yapacağım çok mükemmel olsun diye uğraştıkça gözünüzden kaçan basit hatalar tüm sisteminizin zaafiyetine sebebiyet verir.

  Buna en iyi örnek oyun konsollarıdır. Çünkü Bazı konsollar varki satış rakamlarının çok çok üstünde üretim maliyetleri vardır. Amaç donanımı satıp yazılımdan gelir elde etmek olduğu için güvenlik üst düzeye çıkartılmış olmasına rağmen bu donanımlar kırılmışlardır.


"... a healthy dose of paranoia leads to better systems." Jack Ganssle

Yasal Uyarı: Picproje.org sitemizde 5651 sayılı kanunun 8. maddesine ve T.C.Knın 125. maddesine göre tüm üyelerimiz yaptıkları paylaşımlardan kendileri sorumludur. Picproje.org hakkında yapılacak tüm hukuksal şikayetleri İletişim sayfamızdan bize bildirdikten en geç 3 (üç) iş günü içerisinde ilgili kanunlar ve yönetmelikler çerçevesinde tarafımızca incelenerek gereken işlemler yapılacak ve site yöneticilerimiz tarafından bilgi verilecektir.