SlideShare a Scribd company logo

ImplementingCryptoSecurityARMCortex_Doin

Jonny Doin, profile picture
Jonny Doin

The document discusses implementing cryptography security on a Cortex-M3 microcontroller. It outlines motivations for embedded security and requirements from standards like NIST FIPS-140-2. Details are provided on implementing cryptographic primitives like SHA-256 and HMAC using the ARM architecture. The design of a lightweight embedded security library called GV_Securelib is also described.

1 of 36
Download to read offline
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#ESCBOS #ESCBOS Implemen'ng  Crypto  Security  in  Bare-­‐Metal  Cortex-­‐M3   Jonny  Doin  –  GridVortex  
#ESCBOS First,  a  li*le  about  me Disclaimer:  I  am  NOT  a  cryptographer.     I  design  and  implement  Embedded  Systems  for  cri=cal  applica=ons.     Along  the  years  I  was  deeply  involved  with  Hardware  Design,  Analog   Electronics,  Chip  Design,  Firmware,  Networking,  Security.   I  see  Embedded  Design  as  a  con=nuum  that  encompasses  all  of  the   above,  in  a  harmonious  System,  targeted  to  specific  func=onali=es.     That  is  a  very  useful  vision  when  implemen=ng  Embedded  Security.  
#ESCBOS Agenda •  Mo=va=ons   •  Requirements  for  Security  Systems:  NIST  FIPS-­‐140-­‐2   •  Standard  documents:  NIST  and  RFCs   •  Design  decisions   •  Implementa=on  details:  SHA-­‐256,  HMAC,  (N)RBG   •  Digital  Signatures,  keys  and  hardware  accelera=on   •  RAM  secureFence   •  Tamper  and  Fraud  detec=on   hXp://www.sourcesecurity.com/images/moreimages/PCSC-­‐fault-­‐tolerance-­‐250.jpg  
#ESCBOS Mo6va6ons We  think  the  SmartCity  cannot  happen  without  strong   Embedded  Security.   This  presenta=on  is  a  walkthrough  on  the  design   and  implementa=on  of  our  Embedded  Security  Lib   for  Cortex-­‐M,  with  some  detail  on  the  how-­‐to   implement  some  basic  blocks.     hXp://c^matrix.com/wp-­‐content/uploads/2013/11/alice-­‐in-­‐matrix.jpg   At  GridVortex,  we  decided  to  write  our  Security  Library  from  scratch.     Embedded  Security  is  an  important  aspect  of  all  the  systems  we  are   designing  right  now,  including  IoT  chip  design.  
#ESCBOS Requirements:  Legal  Metrology •  Soaware  requirements  for  Legal  Metrology  systems  are  emerging   •  Demand  for  an=-­‐fraud  on  smart  meters,  fuel  dispensers  and  weight   scales   •  Strong  Digital  Signature  support   •  Firmware  iden=fica=on  and  verifica=on     •  Tamper  detec=on  and  conten=on   •  Source-­‐code  Cer=fica=on  on  the  Embedded  Firmware    
#ESCBOS Requirements:  NIST  FIPS-­‐140-­‐2 •  Specifies  the  minimum  requirements  for  cryptographic  modules   •  Provides  cer=fica=on  recommenda=ons  for  4  levels  of  security   •  We  need  to  cer=fy  systems  at  Levels  2  and  3   •  All  modules  shall:   •  Show  Security  Status   •  Perform  Self-­‐Tests   •  Perform  Approved  Security  Func=ons   •  Tamper  detec=on  and  response   •  User  authen=ca=on  is  required  to  access  secrets  and   configura=on  
#ESCBOS Standard  Docs:  NIST  and  RFCs •  Cryptography  is  NOT  a  secret   •  Strong  cryptography  is  a  technology  available  to  everyone   •  All  algorithms  and  construc=ons  are  FREE  published  standards   •  You  can  download  them  from  NIST  publica=ons  and  IETF  RFCs   •  Algorithms,  Implementa=on  Recommenda=ons,  Test  Vectors   •  Every  implementa=on  needs  to  follow  these  requirements  and  docs  
#ESCBOS Design  Decisions:    GV_Securelib •  Simple,  Lightweight,  proper,  support  for  Security   •  Op=mized  for  ARM-­‐Cortex-­‐M   •  Hybrid  Implementa=on:     Fast  Firmware  for  base  func=ons   Hardware  Accelera=on  for  expensive  func=ons   Key  storage  uses  dedicated  Hardware   Services  with  State-­‐Machine  friendly  callback  messages   •  Support  for  standard  data  encodings   •  High  Reliability  (full  fault  detec=on)   SHA-­‐256   HMAC   DRBG   True  RNG   ECDSA  SIGN  /  VERIFY   Key  Gen/KDF   BASE64   CRC16   CRC32   CryptoSeal   X.509   RAM  secureFence   Passwd   SecureDB  
#ESCBOS Implemen6ng:  SHA-­‐256 SHA-­‐256  is  a  block  transforma=on  func=on  that  operates  on  512bit  blocks,   and  generates  a  256bit  output  register.   For  a  silicon  implementa=on,  SHA-­‐256  is  usually  designed  as  a  pipelined   register  machine,  with  256-­‐wide  parallel  logic,  that  produces  a  block  hash   on  ~68  clocks,  depending  on  the  implementa=on.     It  has  3  large  logic  blocks:     the  message  schedule   the  core  block  hash   the  output  register       Message! schedule! ! 16 * 32! registers! core! logic! ! 8 * 32! registers! output! 8*32 regs! message! any ! length!
#ESCBOS Implemen6ng:  SHA-­‐256  (1) The  core  block  is  where  the  ac=on   is.  (this  is  a  simplified  schema=c  of  the  logic)   This  block  has  8  registers  and  the   ARX  (Add-­‐Rotate-­‐Xor)  func=ons.     It  takes  66  clock  cycles  to   compute  a  hash  block  of  64  bytes.   {A..H}  are  the  output  registers.   Aaer  64  clocks,  {A..H}  +=  {a..h}     ⊕! 32 bit reg ‘a’! 32 bit reg ‘b’! 32 bit reg ‘c’! 32 bit reg ‘d’! 32 bit reg ‘e’! 32 bit reg ‘f’! 32 bit reg ‘g’! 32 bit reg ‘h’! Maj! ∑0 ! comb! logic! Ch! ∑1 ! comb! logic,! sum! A B C D E F G H
#ESCBOS Implemen6ng:  SHA-­‐256  (2) ARM  Architectural  traits  related  to  SHA-­‐256  logic:   •  16  CPU  registers  (can  hold  the  8  core  registers  in  the  CPU)   •  Barrel  Shiaer  coupled  to  ALU  opera=on  (mul=ple  opera=ons)   EOR        r10,r10,r6,ROR  #11  ;  r10  ^=  (r6  >>  11  |  ((r6  <<  21)  &  0xFFFFFFFF))   •  Byte-­‐reverse  opera=ons  (Can  work  on  big-­‐endian  data)   REV        r6,r6  ;  ntoh(r6)   We  can  write  SHA-­‐256  with  minimum  RAM  access  for  the  core  logic,  and   minimized  stack  footprint.     By  reducing  memory  accesses,  we  improve  both  speed  and  security.  
#ESCBOS Implemen6ng:  SHA-­‐256  (3) With  these  aspects  in  mind,  we  implemented  the  core  logic  with:   •  100  stack  bytes,  instead  of  the  original  288  stack  bytes   •  Zero  memory  access  for  the  {a..h}  registers   •  Only  one  access  per  permuta=on  for  the  Ki  constants   •  3  loads  and  1  store  for  the  Wt  array   •  Zero-­‐stack  footprint  for  the  H[0..7]  array   •  Zero-­‐copy  logic  for  the  whole  core   •  Fused  algorithm  for  the  Schedule  and  Core,  resul=ng  in  a  single  pass     The  resul=ng  SHA-­‐256  takes  less  than  25us  per  64-­‐byte  block  for  a  complete   hash  computa=on,  comparing  very  favorably  to  x86  soaware   implementa=ons.      
#ESCBOS Implemen6ng:  SHA-­‐256  (4) Details:   {   a  =  hctx-­‐>H[0];   ...   h  =  hctx-­‐>H[7];     ARX(a,  b,  c,  d,  e,  f,  g,  h,  Wm(  0),  0x428A2F98);   ARX(h,  a,  b,  c,  d,  e,  f,  g,  Wm(  1),  0x71374491);   ...   ARX(c,  d,  e,  f,  g,  h,  a,  b,  Wt(62),  0xBEF9A3F7);   ARX(b,  c,  d,  e,  f,  g,  h,  a,  Wt(63),  0xC67178F2);     hctx-­‐>H[0]  +=  a;   ...   hctx-­‐>H[7]  +=  h;   }   Each  line  ARX  macro  is  one  ‘clock’  of  the  core  logic   Schedule  and  Internal  arrays  scanned  in  one  pass   Registers  are  ‘shiaed’  through  the  ARX  network  
#ESCBOS Implemen6ng:  SHA-­‐256  (5) The  ARX  network  macros:     #define  s0(x)      (RRX((x),  7)  ^  RRX((x),18)  ^  SHR((x),  3))   #define  s1(x)      (RRX((x),17)  ^  RRX((x),19)  ^  SHR((x),10))   #define  SIG0(x)  (RRX((x),  2)  ^  RRX((x),13)  ^  RRX((x),22))   #define  SIG1(x)  (RRX((x),  6)  ^  RRX((x),11)  ^  RRX((x),25))   #define  Ch(x,y,z)    ((x  &  y)  +  ((~x)  &  z))   #define  Maj(x,y,z)  ((y  &  (x  ^  z))  +  (x  &  z))   #define  Wm(t)  (W[t]  =  REV(M[t]))   #define  Wt(t)  (W[t  &  0xF]  +=  s0(W[(t  +  1)  &  0xF])  +  s1(W[(t  +  14)  &  0xF])  +  W[(t  +  9)  &  0xF])     #define  ARX(a,b,c,d,e,f,g,h,Wi,Ki)                                       {                                                                                                                uint32_t  T  =  h  +  Ch(e,f,g)  +  SIG1(e)  +  Wi  +  Ki;            d  +=  T;                                                                                            h  =  T  +  Maj(a,b,c)  +  SIG0(a);                                         }    
#ESCBOS Implemen6ng:  SHA-­‐256  (6) One  ARX  iteration:     0x0003E820  EA070A08  AND      r10,r7,r8   0x0003E824  EA240B07  BIC      r11,r4,r7   0x0003E828  44DA          ADD      r10,r10,r11   0x0003E82A  4456          ADD      r6,r6,r10   0x0003E82C  EA4F1AB7  ROR      r10,r7,#6   0x0003E830  EA8A2AF7  EOR      r10,r10,r7,ROR  #11   0x0003E834  EA8A6A77  EOR      r10,r10,r7,ROR  #25   0x0003E838  4456          ADD      r6,r6,r10   0x0003E83A  F8DDA02C  LDR      r10,[sp,#0x2C]   0x0003E83E  EA4F1BFA  ROR      r11,r10,#7   0x0003E842  EA8B4BBA  EOR      r11,r11,r10,ROR  #18   0x0003E846  EA8B0BDA  EOR      r11,r11,r10,LSR  #3   0x0003E84A  F8DDA028  LDR      r10,[sp,#0x28]   0x0003E84E  EA4F4E7A  ROR      lr,r10,#17   0x0003E852  EA8E4EFA  EOR      lr,lr,r10,ROR  #19   0x0003E856  EA8E2A9A  EOR      r10,lr,r10,LSR  #10   0x0003E85A  EB0B0E0A  ADD      lr,r11,r10   0x0003E85E  F8DDB04C  LDR      r11,[sp,#0x4C]   0x0003E862  F8DDA030  LDR      r10,[sp,#0x30]   0x0003E866  44DA          ADD      r10,r10,r11   0x0003E868  44F2          ADD      r10,r10,lr   0x0003E86A  4456          ADD      r6,r6,r10   0x0003E86C  F8CDA030  STR      r10,[sp,#0x30]   0x0003E870  F8DFA220  LDR.W  r10,[pc,#544]   0x0003E874  EA030B01  AND      r11,r3,r1   0x0003E878  44B2          ADD      r10,r10,r6   0x0003E87A  EB02060A  ADD      r6,r2,r10   0x0003E87E  EA830201  EOR      r2,r3,r1   0x0003E882  EA02020C  AND      r2,r2,r12   0x0003E886  445A          ADD      r2,r2,r11   0x0003E888  4452          ADD      r2,r2,r10   0x0003E88A  EA4F0AB3  ROR      r10,r3,#2   0x0003E88E  EA8A3A73  EOR      r10,r10,r3,ROR  #13   0x0003E892  EA8A5AB3  EOR      r10,r10,r3,ROR  #22   0x0003E896  4452          ADD      r2,r2,r10   s0   s1   SIG1   Ch   SIG0   Wt   Maj  
#ESCBOS Implemen6ng:  SHA-­‐256  (7) Lib  Interface:     typedef  struct  hash_context_t  {          uint32_t  bytecount;                  //!<  total  message  length  (2**29  bytes  =  536870912  bytes)          volatile  uint32_t  H[8];          //!<  intermediate  hash  value  H(i)          uint8_t  W[64];                            //!<  512bits  hash  data  block          uint8_t  ipad[64];                      //!<  inner  padding  for  HMAC-­‐SHA-­‐256          uint8_t  opad[64];                      //!<  outer  padding  for  HMAC-­‐SHA-­‐256   }  HASH_CONTEXT_T;     const  char  *str_secure_status(SECURE_STATUS_T  err_code);   SECURE_STATUS_T  sha256_init(HASH_CONTEXT_T  *hctx);                                                                              //!<  Initialize  context   SECURE_STATUS_T  sha256_uninit(HASH_CONTEXT_T  *hctx);                                                                          //!<  Clear  SHA-­‐256  context   SECURE_STATUS_T  sha256_begin(HASH_CONTEXT_T  *hctx);                                                                            //!<  SHA-­‐256  context  setup   SECURE_STATUS_T  sha256_update(HASH_CONTEXT_T  *hctx,  const  void  *input,  size_t  length);      //!<  SHA-­‐256  digest  update   SECURE_STATUS_T  sha256_end(HASH_CONTEXT_T  *hctx,  uint8_t  output[32]);                                        //!<  SHA-­‐256  final  digest   SECURE_STATUS_T  sha256(const  void  *input,  size_t  ilen,  uint8_t  output[32]);                            //!<  output  =  SHA-­‐256(input)  
#ESCBOS Implemen6ng:  HMAC-­‐SHA-­‐256 The  HMAC  construc=on  encapsulates  the  hash  func=on,  and  is   considered  much  harder  to  crack.     Once  you  have  SHA-­‐256,  the  HMAC-­‐SHA-­‐256  is  straightorward  to   implement.     HMAC  has  the  following  construc=on:      HMAC(K,  text)  =  H((Ko  ⊕  opad  )||  H((Ki  ⊕  ipad)  ||  text))       inner  hash   outer  hash  
#ESCBOS Implemen6ng:  HMAC-­‐SHA-­‐256  (2) SECURE_STATUS_T  hmac_sha256_begin(HASH_CONTEXT_T  *hctx,  const  void  *key,  size_t  keylen)   {          ....          sha256_begin(hctx);            return  sha256_update(hctx,  hctx-­‐>ipad,  64);  //  H(key  xor  ipad)   }     SECURE_STATUS_T  hmac_sha256_update(HASH_CONTEXT_T  *hctx,  const  void  *input,  size_t  length)   {          return  sha256_update(hctx,  input,  length);  //  hash  message  blocks   }     SECURE_STATUS_T  hmac_sha256_end(HASH_CONTEXT_T  *hctx,  uint8_t  output[32])   {          sha256_end(hctx,  hctx-­‐>ipad);    //  terminate  inner  hash:  H(Ki  //  message)          sha256_begin(hctx);        //  initialize  SHA-­‐256  context  for  outer  hash          sha256_update(hctx,  hctx-­‐>opad,  64);    //  H(Ko)          sha256_update(hctx,  hctx-­‐>ipad,  32);    //  H(Ko  //  H(Ki  //  message))          sha256_end(hctx,  output);      //  output  the  final  hash          sha256_uninit(hctx);        //  destroy  all  data  in  hash  context          return  sec_status;   }  
#ESCBOS Random  Numbers  Genera6on Random,  unpredictable  Numbers  are  the  hardcore  of  secure  systems.     High  quality  random  numbers  require  a  source  of  unpredictability  with  a   large  number  of  states.     The  general  structure  of  a  RNG  is  this:         NIST  Special  PUB  800-­‐90A/B/C  define  the  recommenda=ons  for   implemen=ng  DRBGs.    
#ESCBOS Implemen6ng:  HMAC-­‐DRBG The  Instantiate  func=on  creates  a  new  DRBG  context.  
#ESCBOS Implemen6ng:  HMAC-­‐DRBG  (2) The  Generate  func=on  computes  a  fresh  random  output.  
#ESCBOS Implemen6ng:  HMAC-­‐DRBG  (3) The  Reseed  func=on  restarts  the  DRBG  with  fresh  entropy  data.    
#ESCBOS Implemen6ng:  Entropy  Source We  need  uncorrelated  noise   sources  as  the  source  of  entropy.     All  the  ADC  analog  sensors  lower   bits  are  used  as  noise  sources.     The  noise  is  de-­‐biased  through  a   Von  Neumann  de-­‐bias  filter,  and   collected  into  a  2048bit     entropy  pool.  
#ESCBOS Implemen6ng:  Entropy  Source  (2) The  entropy  source  takes  960bits  of  noise  data  and  applies  2  parallel   HMAC  condi=oning  func=ons,  using  the  CPU  chip  SN  as  the  key.     This  produces  very  high  quality,  very  high  entropy  seed  material.  
#ESCBOS Implemen6ng:  Entropy  Source  (3) The  entropy  source  also  produces  high  quality  cryptographic  nonces.    
#ESCBOS Implemen6ng:  (N)RBG When  you  add  a  ‘live’  entropy  source  to  an  instan=ated  HMAC-­‐DRBG,   that  is  con=nuously  reseeded  with  fresh,  high-­‐entropy  data,  you  get  a   NRBG  (Non-­‐Determinis=c  Random  Bit  Generator),  or  an  approved   True  Random  Number  Generator  !     This  is  a  fast,  high-­‐quality  keying  material  generator  for  the  system.   Entropy! Source! HMAC! DRBG! NOISE! SRC! continuous! reseed! high quality TRNG (!) ! 2048   bit   Pool  
#ESCBOS Digital  Signatures:  ATECC108A Ellip=c  Curves  DSA  (ECDSA)  is  one  of  the  strongest  public-­‐key   cryptographic  signature  algorithms  today.       One  problem  is  that  it  is  expensive  to  implement  in  a  microcontroller.     We  selected  a  cer=fied,  external  ECDSA  accelerator  that  also  works   as  a  secure  EEPROM  to  store  the  private  keys,  increasing  system   compliance  to  FIPS-­‐140-­‐2  level  2  and  3.       The  device  is  the  Atmel  (now  Microchip)  ATECC108A.     We  designed  the  ECDSA  sign/verify  as  a  system  service  around  the   crypto  memory.  
#ESCBOS Digital  Signatures:  ATECC108A  (2) The  driver  takes  the  chip  out  of  IDLE  state  (chip  wake  up)    
#ESCBOS Digital  Signatures:  ATECC108A  (3) The  command  executes  in  the  BUSY  state.  The  chip  is  unresponsive   during  BUSY.    
#ESCBOS Digital  Signatures:  ATECC108A  (4) Aaer  the  command  returns,  the  chip  is  placed  in  IDLE  again.    
#ESCBOS Digital  Signatures:  ATECC108A  (5) The  actual  driver  code   accounts  for  every   possible  error  and  bus   =meout.  
#ESCBOS Implemen6ng:  ECDSA  Sign/Verify Lib  Interface:     /**  Descriptor  for  ECC  sign/verify  operations.  */   typedef  struct  ecdsa_vector_t  {          LAP_TIMER64_T  lap_timer64;                                    //!<  64  bit  lap  timer  for  this  operation          ECC_KEY_TYPES_T  key_type;                                      //!<  Key  type,  curve  and  key  storage          uint32_t  slot  :  8;                                                    //!<  Key  slot  for  internal  keys          uint32_t  key_length;                                                //!<  public  key  data  length          uint32_t  signature_length;                                    //!<  signature  data  length            uint8_t  *msg_hash;                                                    //!<  ptr  to  the  32-­‐byte  Message  hash  (SHA-­‐256)          uint8_t  *key_data;                                                    //!<  ptr  to  the  External  Key  buffer          uint8_t  *signature;                                                  //!<  ptr  to  the  Signature  buffer  generated  by  ecdsa_sign()   }  ECDSA_VECTOR_T;     SECURE_STATUS_T  ecdsa_sign(ECDSA_VECTOR_T  *vector,  ECDSA_CMD_EVENT_T  *event);   SECURE_STATUS_T  ecdsa_verify(ECDSA_VECTOR_T  *vector,  ECDSA_CMD_EVENT_T  *event);    
#ESCBOS RAM  secureFence One  of  the  services  available  is  the  secureFence  service.     Applica=ons  can  request  that  certain  structs  be  locked  as  immutable  data.     The  structs  are  signed  with  a  random  key  and  checked  every  system  pass.     hXp://i2.wp.com/patriot-­‐tech.com/wp-­‐content/uploads/2014/06/SCADA_security.jpg   If  the  struct  is  modified  by  unauthorized  code  or   wild  pointers,  the  service  generates  a  FAULT,  and   the  system  is  reset.   It  effec=vely  places  a  crypto  fence  around  system   sensi=ve  data,  such  as  calibra=on  constants  and   measurement  results.        
#ESCBOS RAM  secureFence  (2)  //  -­‐-­‐-­‐  register  secureFence  service  -­‐-­‐-­‐          if(!register_struct_as_secure(                          &(SECURE_MEM_PARAMETERS_T){                                  .struct_ptr                  =  &weighing_setup,                                  .struct_size                =  sizeof(weighing_setup),                                  .str_struct_name        =  "weighing_setup{}"},                          &weighing_data.secure)          )      throw_app_fault(__FUNCTION__,  ":  error  registering  secure  struct.");     static  WEIGHING_ERROR_T  set_adc_sampling_rate(float  rate_sps)   {          WEIGHING_ERROR_T  status;                    weighing_data.secure.open();                                                                                        //  open  vault:  allow  modifications          status  =  adc-­‐>set_sampling_rate(rate_sps);          weighing_setup.sampling_rate  =  adc-­‐>get_sampling_rate();          status  =  weighing_data.persistent.save()  ?  status  :  ADC_ERR_FAILURE;          weighing_data.secure.close();                                                                                      //  secure  vault:  protect  data                    return  status;   }    
#ESCBOS Tamper  and  Fraud  detec6on SHA-­‐256   HMAC   DRBG   True  RNG   ECDSA  SIGN  /  VERIFY   Key  Gen/KDF   BASE64   CRC16   CRC32   CryptoSeal   X.509   RAM  secureFence   Passwd   SecureDB   Public  Key  Cryptography     User  Authen=ca=on   Secure  LOGs   RAM  Tamper  Detec=on   Calibra=on  Crypto  Seal   Fast  hash  func=ons   High-­‐quality  Keys   PKI  Cer=ficates  
#ESCBOS Thank  you   Jonny  Doin   jonnydoin@gridvortex.com    

More Related Content

PPTX
1300 david oswald id and ip theft with side-channel attacks
Positive Hack Days
 
PDF
Side Channel Attacks on AES
Ravi Prakash Giri
 
PPTX
Blockchain Cryptography for Developers (Nakov @ BlockWorld 2018, San Jose)
Svetlin Nakov
 
PDF
IT6712 lab manual
Madhu Amarnath
 
PPTX
Cisco IOS shellcode: All-in-one
DefconRussia
 
PDF
Проблемы использования TCP в мобильных приложениях. Владимир Кириллов
Anthony Marchenko
 
PDF
[2012 CodeEngn Conference 06] pwn3r - Secuinside 2012 CTF 예선 문제풀이
Code Engn
 
PDF
Geth important commands
NexThoughts Technologies
 
1300 david oswald id and ip theft with side-channel attacks
Positive Hack Days
 
Side Channel Attacks on AES
Ravi Prakash Giri
 
Blockchain Cryptography for Developers (Nakov @ BlockWorld 2018, San Jose)
Svetlin Nakov
 
IT6712 lab manual
Madhu Amarnath
 
Cisco IOS shellcode: All-in-one
DefconRussia
 
Проблемы использования TCP в мобильных приложениях. Владимир Кириллов
Anthony Marchenko
 
[2012 CodeEngn Conference 06] pwn3r - Secuinside 2012 CTF 예선 문제풀이
Code Engn
 
Geth important commands
NexThoughts Technologies
 

What's hot (20)

PDF
Владимир Кириллов-TCP-Performance for-Mobile-Applications
UA Mobile
 
PPT
Cs423 raw sockets_bw
jktjpc
 
PDF
44CON London 2015 - Reverse engineering and exploiting font rasterizers: the ...
44CON
 
PDF
Keccak
Rajeev Verma
 
PPT
Opentalk at Large - StS 2005
Martin Kobetic
 
PDF
Half-Century of Unix; History, Preservation, and Lessons Learned
OW2
 
PDF
Advanced cfg bypass on adobe flash player 18 defcon russia 23
DefconRussia
 
PDF
Warp 10 Platform Presentation - Criteo Beer & Tech 2016-02-03
Mathias Herberts
 
PPTX
Find the Hacker
Sysdig
 
PPT
Socket Programming
Sivadon Chaisiri
 
PPTX
System Calls
David Evans
 
PPTX
How to Secure Containers
Sysdig
 
PPTX
SHA-3, Keccak & Sponge function
Gennaro Caccavale
 
PDF
Sha3
Jyun-Yao Huang
 
PDF
Sergi Álvarez + Roi Martín - radare2: From forensics to bindiffing [RootedCON...
RootedCON
 
PDF
Salsa20
Amit Ghosh
 
PPTX
Symmetric encryption
DR RICHMOND ADEBIAYE
 
PPTX
Угадываем пароль за минуту
Positive Hack Days
 
PDF
Ieee 1149.1-2013-tutorial-ijtag
Venkateshwar Motamarri
 
PDF
Mikhail Belopuhov: OpenBSD: Where is crypto headed?
Yandex
 
Владимир Кириллов-TCP-Performance for-Mobile-Applications
UA Mobile
 
Cs423 raw sockets_bw
jktjpc
 
44CON London 2015 - Reverse engineering and exploiting font rasterizers: the ...
44CON
 
Keccak
Rajeev Verma
 
Opentalk at Large - StS 2005
Martin Kobetic
 
Half-Century of Unix; History, Preservation, and Lessons Learned
OW2
 
Advanced cfg bypass on adobe flash player 18 defcon russia 23
DefconRussia
 
Warp 10 Platform Presentation - Criteo Beer & Tech 2016-02-03
Mathias Herberts
 
Find the Hacker
Sysdig
 
Socket Programming
Sivadon Chaisiri
 
System Calls
David Evans
 
How to Secure Containers
Sysdig
 
SHA-3, Keccak & Sponge function
Gennaro Caccavale
 
Sha3
Jyun-Yao Huang
 
Sergi Álvarez + Roi Martín - radare2: From forensics to bindiffing [RootedCON...
RootedCON
 
Salsa20
Amit Ghosh
 
Symmetric encryption
DR RICHMOND ADEBIAYE
 
Угадываем пароль за минуту
Positive Hack Days
 
Ieee 1149.1-2013-tutorial-ijtag
Venkateshwar Motamarri
 
Mikhail Belopuhov: OpenBSD: Where is crypto headed?
Yandex
 
Ad

Viewers also liked (20)

PPTX
Gerunds
Universidad Tecnológica de Pereira
 
PPTX
Where does it hurt?
Universidad Tecnológica de Pereira
 
DOCX
Posiciones juradas probatorio
NesmaryPalluotto
 
DOCX
5ta actividad
NesmaryPalluotto
 
PPTX
Personas juridicas del dip
NesmaryPalluotto
 
PDF
highly recommended student's book
melanie hernandez
 
PDF
Talento humano consultoría humana slide share
Consultoría Humana
 
PDF
TelCo_Sales_p1506jun_Corporate_Profile_(i)Brochure_R01V07_varEN_RGB
Paraschos Oikonomou
 
PPTX
Content Marketing_Tiyasa Saha
tiyasa saha
 
PDF
TESTMONIALS 1
Daniel Ndegwa
 
PPTX
AutoCAD
Hamerly Sanchez Vilchez
 
PPTX
Contratos informáticos y contratos electrónicos
Marcela Rebeca Del Pino Solis
 
PDF
Sts 401 slides-doin
Jonny Doin
 
PPTX
Fuentes derecho internacional privado
NesmaryPalluotto
 
PDF
BBTECHSPECS_CN.EN.v2016 (2)
Ophir Fromm
 
PPTX
Outline India Storyboard 2016
Outline India
 
PPTX
AutoCAD
Hamerly Sanchez Vilchez
 
PDF
Transmission Summit 2016- Halpern
Jack Halpern
 
PDF
Impacto metrologialegal jonnydoin
Jonny Doin
 
PPTX
Will and would
Universidad Tecnológica de Pereira
 
Gerunds
Universidad Tecnológica de Pereira
 
Where does it hurt?
Universidad Tecnológica de Pereira
 
Posiciones juradas probatorio
NesmaryPalluotto
 
5ta actividad
NesmaryPalluotto
 
Personas juridicas del dip
NesmaryPalluotto
 
highly recommended student's book
melanie hernandez
 
Talento humano consultoría humana slide share
Consultoría Humana
 
TelCo_Sales_p1506jun_Corporate_Profile_(i)Brochure_R01V07_varEN_RGB
Paraschos Oikonomou
 
Content Marketing_Tiyasa Saha
tiyasa saha
 
TESTMONIALS 1
Daniel Ndegwa
 
AutoCAD
Hamerly Sanchez Vilchez
 
Contratos informáticos y contratos electrónicos
Marcela Rebeca Del Pino Solis
 
Sts 401 slides-doin
Jonny Doin
 
Fuentes derecho internacional privado
NesmaryPalluotto
 
BBTECHSPECS_CN.EN.v2016 (2)
Ophir Fromm
 
Outline India Storyboard 2016
Outline India
 
AutoCAD
Hamerly Sanchez Vilchez
 
Transmission Summit 2016- Halpern
Jack Halpern
 
Impacto metrologialegal jonnydoin
Jonny Doin
 
Will and would
Universidad Tecnológica de Pereira
 
Ad

Similar to ImplementingCryptoSecurityARMCortex_Doin (20)

PPTX
Overview on Cryptography and Network Security
Dr. Rupa Ch
 
PPTX
Evgeniy Muralev, Mark Vince, Working with the compiler, not against it
Sergey Platonov
 
PPTX
Lec05
siddu kadiwal
 
PDF
Nikita Abdullin - Reverse-engineering of embedded MIPS devices. Case Study - ...
DefconRussia
 
PDF
R and cpp
Romain Francois
 
PDF
ParallelLogicToEventDrivenFirmware_Doin
Jonny Doin
 
PPTX
Cryptography for Absolute Beginners (May 2019)
Svetlin Nakov
 
PDF
Aes
Manju Hegde
 
PDF
Modern C++
Michael Clark
 
PPT
Fault Detection Scheme for AES Using Composite Field
AJAL A J
 
PPTX
Week1 Electronic System-level ESL Design and SystemC Begin
敬倫 林
 
PDF
Shellcoding in linux
Ajin Abraham
 
PPTX
Java on arm theory, applications, and workloads [dev5048]
Aleksei Voitylov
 
PPT
Alden Hart and Rob Giesburt at Hardware Innovation Summit 2013
makezine
 
PPTX
Modern Linux Tracing Landscape
Sasha Goldshtein
 
PDF
20141105 asfws-norx-slides
Cyber Security Alliance
 
PDF
GOD MODE UNLOCKED - Hardware Backdoors in x86 CPUs
Priyanka Aash
 
PDF
深層学習フレームワークにおけるIntel CPU/富岳向け最適化法
MITSUNARI Shigeo
 
PDF
Lie to Me: Bypassing Modern Web Application Firewalls
Ivan Novikov
 
PPT
Arduino Platform with C programming.
Govind Jha
 
Overview on Cryptography and Network Security
Dr. Rupa Ch
 
Evgeniy Muralev, Mark Vince, Working with the compiler, not against it
Sergey Platonov
 
Lec05
siddu kadiwal
 
Nikita Abdullin - Reverse-engineering of embedded MIPS devices. Case Study - ...
DefconRussia
 
R and cpp
Romain Francois
 
ParallelLogicToEventDrivenFirmware_Doin
Jonny Doin
 
Cryptography for Absolute Beginners (May 2019)
Svetlin Nakov
 
Aes
Manju Hegde
 
Modern C++
Michael Clark
 
Fault Detection Scheme for AES Using Composite Field
AJAL A J
 
Week1 Electronic System-level ESL Design and SystemC Begin
敬倫 林
 
Shellcoding in linux
Ajin Abraham
 
Java on arm theory, applications, and workloads [dev5048]
Aleksei Voitylov
 
Alden Hart and Rob Giesburt at Hardware Innovation Summit 2013
makezine
 
Modern Linux Tracing Landscape
Sasha Goldshtein
 
20141105 asfws-norx-slides
Cyber Security Alliance
 
GOD MODE UNLOCKED - Hardware Backdoors in x86 CPUs
Priyanka Aash
 
深層学習フレームワークにおけるIntel CPU/富岳向け最適化法
MITSUNARI Shigeo
 
Lie to Me: Bypassing Modern Web Application Firewalls
Ivan Novikov
 
Arduino Platform with C programming.
Govind Jha
 

More from Jonny Doin (9)

PPTX
Jonny doin safe io t- lt_spice failsafe
Jonny Doin
 
PDF
Jonny doin lt spice servo_dac
Jonny Doin
 
PDF
Esc 209 slides-doin
Jonny Doin
 
PDF
Esc 209 paper_doin
Jonny Doin
 
PDF
Network insecuritysimplehackscortexm jonnydoin
Jonny Doin
 
PDF
Io t hurdles_i_pv6_slides_doin
Jonny Doin
 
PDF
Implementing lora smartcity doin
Jonny Doin
 
PDF
Csc jonny doin_painel1_sm
Jonny Doin
 
PDF
SiliconFailsafeForIoT_Doin
Jonny Doin
 
Jonny doin safe io t- lt_spice failsafe
Jonny Doin
 
Jonny doin lt spice servo_dac
Jonny Doin
 
Esc 209 slides-doin
Jonny Doin
 
Esc 209 paper_doin
Jonny Doin
 
Network insecuritysimplehackscortexm jonnydoin
Jonny Doin
 
Io t hurdles_i_pv6_slides_doin
Jonny Doin
 
Implementing lora smartcity doin
Jonny Doin
 
Csc jonny doin_painel1_sm
Jonny Doin
 
SiliconFailsafeForIoT_Doin
Jonny Doin
 

ImplementingCryptoSecurityARMCortex_Doin

  • 1. #ESCBOS #ESCBOS Implemen'ng  Crypto  Security  in  Bare-­‐Metal  Cortex-­‐M3   Jonny  Doin  –  GridVortex  
  • 2. #ESCBOS First,  a  li*le  about  me Disclaimer:  I  am  NOT  a  cryptographer.     I  design  and  implement  Embedded  Systems  for  cri=cal  applica=ons.     Along  the  years  I  was  deeply  involved  with  Hardware  Design,  Analog   Electronics,  Chip  Design,  Firmware,  Networking,  Security.   I  see  Embedded  Design  as  a  con=nuum  that  encompasses  all  of  the   above,  in  a  harmonious  System,  targeted  to  specific  func=onali=es.     That  is  a  very  useful  vision  when  implemen=ng  Embedded  Security.  
  • 3. #ESCBOS Agenda •  Mo=va=ons   •  Requirements  for  Security  Systems:  NIST  FIPS-­‐140-­‐2   •  Standard  documents:  NIST  and  RFCs   •  Design  decisions   •  Implementa=on  details:  SHA-­‐256,  HMAC,  (N)RBG   •  Digital  Signatures,  keys  and  hardware  accelera=on   •  RAM  secureFence   •  Tamper  and  Fraud  detec=on   hXp://www.sourcesecurity.com/images/moreimages/PCSC-­‐fault-­‐tolerance-­‐250.jpg  
  • 4. #ESCBOS Mo6va6ons We  think  the  SmartCity  cannot  happen  without  strong   Embedded  Security.   This  presenta=on  is  a  walkthrough  on  the  design   and  implementa=on  of  our  Embedded  Security  Lib   for  Cortex-­‐M,  with  some  detail  on  the  how-­‐to   implement  some  basic  blocks.     hXp://c^matrix.com/wp-­‐content/uploads/2013/11/alice-­‐in-­‐matrix.jpg   At  GridVortex,  we  decided  to  write  our  Security  Library  from  scratch.     Embedded  Security  is  an  important  aspect  of  all  the  systems  we  are   designing  right  now,  including  IoT  chip  design.  
  • 5. #ESCBOS Requirements:  Legal  Metrology •  Soaware  requirements  for  Legal  Metrology  systems  are  emerging   •  Demand  for  an=-­‐fraud  on  smart  meters,  fuel  dispensers  and  weight   scales   •  Strong  Digital  Signature  support   •  Firmware  iden=fica=on  and  verifica=on     •  Tamper  detec=on  and  conten=on   •  Source-­‐code  Cer=fica=on  on  the  Embedded  Firmware    
  • 6. #ESCBOS Requirements:  NIST  FIPS-­‐140-­‐2 •  Specifies  the  minimum  requirements  for  cryptographic  modules   •  Provides  cer=fica=on  recommenda=ons  for  4  levels  of  security   •  We  need  to  cer=fy  systems  at  Levels  2  and  3   •  All  modules  shall:   •  Show  Security  Status   •  Perform  Self-­‐Tests   •  Perform  Approved  Security  Func=ons   •  Tamper  detec=on  and  response   •  User  authen=ca=on  is  required  to  access  secrets  and   configura=on  
  • 7. #ESCBOS Standard  Docs:  NIST  and  RFCs •  Cryptography  is  NOT  a  secret   •  Strong  cryptography  is  a  technology  available  to  everyone   •  All  algorithms  and  construc=ons  are  FREE  published  standards   •  You  can  download  them  from  NIST  publica=ons  and  IETF  RFCs   •  Algorithms,  Implementa=on  Recommenda=ons,  Test  Vectors   •  Every  implementa=on  needs  to  follow  these  requirements  and  docs  
  • 8. #ESCBOS Design  Decisions:    GV_Securelib •  Simple,  Lightweight,  proper,  support  for  Security   •  Op=mized  for  ARM-­‐Cortex-­‐M   •  Hybrid  Implementa=on:     Fast  Firmware  for  base  func=ons   Hardware  Accelera=on  for  expensive  func=ons   Key  storage  uses  dedicated  Hardware   Services  with  State-­‐Machine  friendly  callback  messages   •  Support  for  standard  data  encodings   •  High  Reliability  (full  fault  detec=on)   SHA-­‐256   HMAC   DRBG   True  RNG   ECDSA  SIGN  /  VERIFY   Key  Gen/KDF   BASE64   CRC16   CRC32   CryptoSeal   X.509   RAM  secureFence   Passwd   SecureDB  
  • 9. #ESCBOS Implemen6ng:  SHA-­‐256 SHA-­‐256  is  a  block  transforma=on  func=on  that  operates  on  512bit  blocks,   and  generates  a  256bit  output  register.   For  a  silicon  implementa=on,  SHA-­‐256  is  usually  designed  as  a  pipelined   register  machine,  with  256-­‐wide  parallel  logic,  that  produces  a  block  hash   on  ~68  clocks,  depending  on  the  implementa=on.     It  has  3  large  logic  blocks:     the  message  schedule   the  core  block  hash   the  output  register       Message! schedule! ! 16 * 32! registers! core! logic! ! 8 * 32! registers! output! 8*32 regs! message! any ! length!
  • 10. #ESCBOS Implemen6ng:  SHA-­‐256  (1) The  core  block  is  where  the  ac=on   is.  (this  is  a  simplified  schema=c  of  the  logic)   This  block  has  8  registers  and  the   ARX  (Add-­‐Rotate-­‐Xor)  func=ons.     It  takes  66  clock  cycles  to   compute  a  hash  block  of  64  bytes.   {A..H}  are  the  output  registers.   Aaer  64  clocks,  {A..H}  +=  {a..h}     ⊕! 32 bit reg ‘a’! 32 bit reg ‘b’! 32 bit reg ‘c’! 32 bit reg ‘d’! 32 bit reg ‘e’! 32 bit reg ‘f’! 32 bit reg ‘g’! 32 bit reg ‘h’! Maj! ∑0 ! comb! logic! Ch! ∑1 ! comb! logic,! sum! A B C D E F G H
  • 11. #ESCBOS Implemen6ng:  SHA-­‐256  (2) ARM  Architectural  traits  related  to  SHA-­‐256  logic:   •  16  CPU  registers  (can  hold  the  8  core  registers  in  the  CPU)   •  Barrel  Shiaer  coupled  to  ALU  opera=on  (mul=ple  opera=ons)   EOR        r10,r10,r6,ROR  #11  ;  r10  ^=  (r6  >>  11  |  ((r6  <<  21)  &  0xFFFFFFFF))   •  Byte-­‐reverse  opera=ons  (Can  work  on  big-­‐endian  data)   REV        r6,r6  ;  ntoh(r6)   We  can  write  SHA-­‐256  with  minimum  RAM  access  for  the  core  logic,  and   minimized  stack  footprint.     By  reducing  memory  accesses,  we  improve  both  speed  and  security.  
  • 12. #ESCBOS Implemen6ng:  SHA-­‐256  (3) With  these  aspects  in  mind,  we  implemented  the  core  logic  with:   •  100  stack  bytes,  instead  of  the  original  288  stack  bytes   •  Zero  memory  access  for  the  {a..h}  registers   •  Only  one  access  per  permuta=on  for  the  Ki  constants   •  3  loads  and  1  store  for  the  Wt  array   •  Zero-­‐stack  footprint  for  the  H[0..7]  array   •  Zero-­‐copy  logic  for  the  whole  core   •  Fused  algorithm  for  the  Schedule  and  Core,  resul=ng  in  a  single  pass     The  resul=ng  SHA-­‐256  takes  less  than  25us  per  64-­‐byte  block  for  a  complete   hash  computa=on,  comparing  very  favorably  to  x86  soaware   implementa=ons.      
  • 13. #ESCBOS Implemen6ng:  SHA-­‐256  (4) Details:   {   a  =  hctx-­‐>H[0];   ...   h  =  hctx-­‐>H[7];     ARX(a,  b,  c,  d,  e,  f,  g,  h,  Wm(  0),  0x428A2F98);   ARX(h,  a,  b,  c,  d,  e,  f,  g,  Wm(  1),  0x71374491);   ...   ARX(c,  d,  e,  f,  g,  h,  a,  b,  Wt(62),  0xBEF9A3F7);   ARX(b,  c,  d,  e,  f,  g,  h,  a,  Wt(63),  0xC67178F2);     hctx-­‐>H[0]  +=  a;   ...   hctx-­‐>H[7]  +=  h;   }   Each  line  ARX  macro  is  one  ‘clock’  of  the  core  logic   Schedule  and  Internal  arrays  scanned  in  one  pass   Registers  are  ‘shiaed’  through  the  ARX  network  
  • 14. #ESCBOS Implemen6ng:  SHA-­‐256  (5) The  ARX  network  macros:     #define  s0(x)      (RRX((x),  7)  ^  RRX((x),18)  ^  SHR((x),  3))   #define  s1(x)      (RRX((x),17)  ^  RRX((x),19)  ^  SHR((x),10))   #define  SIG0(x)  (RRX((x),  2)  ^  RRX((x),13)  ^  RRX((x),22))   #define  SIG1(x)  (RRX((x),  6)  ^  RRX((x),11)  ^  RRX((x),25))   #define  Ch(x,y,z)    ((x  &  y)  +  ((~x)  &  z))   #define  Maj(x,y,z)  ((y  &  (x  ^  z))  +  (x  &  z))   #define  Wm(t)  (W[t]  =  REV(M[t]))   #define  Wt(t)  (W[t  &  0xF]  +=  s0(W[(t  +  1)  &  0xF])  +  s1(W[(t  +  14)  &  0xF])  +  W[(t  +  9)  &  0xF])     #define  ARX(a,b,c,d,e,f,g,h,Wi,Ki)                                       {                                                                                                                uint32_t  T  =  h  +  Ch(e,f,g)  +  SIG1(e)  +  Wi  +  Ki;            d  +=  T;                                                                                            h  =  T  +  Maj(a,b,c)  +  SIG0(a);                                         }    
  • 15. #ESCBOS Implemen6ng:  SHA-­‐256  (6) One  ARX  iteration:     0x0003E820  EA070A08  AND      r10,r7,r8   0x0003E824  EA240B07  BIC      r11,r4,r7   0x0003E828  44DA          ADD      r10,r10,r11   0x0003E82A  4456          ADD      r6,r6,r10   0x0003E82C  EA4F1AB7  ROR      r10,r7,#6   0x0003E830  EA8A2AF7  EOR      r10,r10,r7,ROR  #11   0x0003E834  EA8A6A77  EOR      r10,r10,r7,ROR  #25   0x0003E838  4456          ADD      r6,r6,r10   0x0003E83A  F8DDA02C  LDR      r10,[sp,#0x2C]   0x0003E83E  EA4F1BFA  ROR      r11,r10,#7   0x0003E842  EA8B4BBA  EOR      r11,r11,r10,ROR  #18   0x0003E846  EA8B0BDA  EOR      r11,r11,r10,LSR  #3   0x0003E84A  F8DDA028  LDR      r10,[sp,#0x28]   0x0003E84E  EA4F4E7A  ROR      lr,r10,#17   0x0003E852  EA8E4EFA  EOR      lr,lr,r10,ROR  #19   0x0003E856  EA8E2A9A  EOR      r10,lr,r10,LSR  #10   0x0003E85A  EB0B0E0A  ADD      lr,r11,r10   0x0003E85E  F8DDB04C  LDR      r11,[sp,#0x4C]   0x0003E862  F8DDA030  LDR      r10,[sp,#0x30]   0x0003E866  44DA          ADD      r10,r10,r11   0x0003E868  44F2          ADD      r10,r10,lr   0x0003E86A  4456          ADD      r6,r6,r10   0x0003E86C  F8CDA030  STR      r10,[sp,#0x30]   0x0003E870  F8DFA220  LDR.W  r10,[pc,#544]   0x0003E874  EA030B01  AND      r11,r3,r1   0x0003E878  44B2          ADD      r10,r10,r6   0x0003E87A  EB02060A  ADD      r6,r2,r10   0x0003E87E  EA830201  EOR      r2,r3,r1   0x0003E882  EA02020C  AND      r2,r2,r12   0x0003E886  445A          ADD      r2,r2,r11   0x0003E888  4452          ADD      r2,r2,r10   0x0003E88A  EA4F0AB3  ROR      r10,r3,#2   0x0003E88E  EA8A3A73  EOR      r10,r10,r3,ROR  #13   0x0003E892  EA8A5AB3  EOR      r10,r10,r3,ROR  #22   0x0003E896  4452          ADD      r2,r2,r10   s0   s1   SIG1   Ch   SIG0   Wt   Maj  
  • 16. #ESCBOS Implemen6ng:  SHA-­‐256  (7) Lib  Interface:     typedef  struct  hash_context_t  {          uint32_t  bytecount;                  //!<  total  message  length  (2**29  bytes  =  536870912  bytes)          volatile  uint32_t  H[8];          //!<  intermediate  hash  value  H(i)          uint8_t  W[64];                            //!<  512bits  hash  data  block          uint8_t  ipad[64];                      //!<  inner  padding  for  HMAC-­‐SHA-­‐256          uint8_t  opad[64];                      //!<  outer  padding  for  HMAC-­‐SHA-­‐256   }  HASH_CONTEXT_T;     const  char  *str_secure_status(SECURE_STATUS_T  err_code);   SECURE_STATUS_T  sha256_init(HASH_CONTEXT_T  *hctx);                                                                              //!<  Initialize  context   SECURE_STATUS_T  sha256_uninit(HASH_CONTEXT_T  *hctx);                                                                          //!<  Clear  SHA-­‐256  context   SECURE_STATUS_T  sha256_begin(HASH_CONTEXT_T  *hctx);                                                                            //!<  SHA-­‐256  context  setup   SECURE_STATUS_T  sha256_update(HASH_CONTEXT_T  *hctx,  const  void  *input,  size_t  length);      //!<  SHA-­‐256  digest  update   SECURE_STATUS_T  sha256_end(HASH_CONTEXT_T  *hctx,  uint8_t  output[32]);                                        //!<  SHA-­‐256  final  digest   SECURE_STATUS_T  sha256(const  void  *input,  size_t  ilen,  uint8_t  output[32]);                            //!<  output  =  SHA-­‐256(input)  
  • 17. #ESCBOS Implemen6ng:  HMAC-­‐SHA-­‐256 The  HMAC  construc=on  encapsulates  the  hash  func=on,  and  is   considered  much  harder  to  crack.     Once  you  have  SHA-­‐256,  the  HMAC-­‐SHA-­‐256  is  straightorward  to   implement.     HMAC  has  the  following  construc=on:      HMAC(K,  text)  =  H((Ko  ⊕  opad  )||  H((Ki  ⊕  ipad)  ||  text))       inner  hash   outer  hash  
  • 18. #ESCBOS Implemen6ng:  HMAC-­‐SHA-­‐256  (2) SECURE_STATUS_T  hmac_sha256_begin(HASH_CONTEXT_T  *hctx,  const  void  *key,  size_t  keylen)   {          ....          sha256_begin(hctx);            return  sha256_update(hctx,  hctx-­‐>ipad,  64);  //  H(key  xor  ipad)   }     SECURE_STATUS_T  hmac_sha256_update(HASH_CONTEXT_T  *hctx,  const  void  *input,  size_t  length)   {          return  sha256_update(hctx,  input,  length);  //  hash  message  blocks   }     SECURE_STATUS_T  hmac_sha256_end(HASH_CONTEXT_T  *hctx,  uint8_t  output[32])   {          sha256_end(hctx,  hctx-­‐>ipad);    //  terminate  inner  hash:  H(Ki  //  message)          sha256_begin(hctx);        //  initialize  SHA-­‐256  context  for  outer  hash          sha256_update(hctx,  hctx-­‐>opad,  64);    //  H(Ko)          sha256_update(hctx,  hctx-­‐>ipad,  32);    //  H(Ko  //  H(Ki  //  message))          sha256_end(hctx,  output);      //  output  the  final  hash          sha256_uninit(hctx);        //  destroy  all  data  in  hash  context          return  sec_status;   }  
  • 19. #ESCBOS Random  Numbers  Genera6on Random,  unpredictable  Numbers  are  the  hardcore  of  secure  systems.     High  quality  random  numbers  require  a  source  of  unpredictability  with  a   large  number  of  states.     The  general  structure  of  a  RNG  is  this:         NIST  Special  PUB  800-­‐90A/B/C  define  the  recommenda=ons  for   implemen=ng  DRBGs.    
  • 20. #ESCBOS Implemen6ng:  HMAC-­‐DRBG The  Instantiate  func=on  creates  a  new  DRBG  context.  
  • 21. #ESCBOS Implemen6ng:  HMAC-­‐DRBG  (2) The  Generate  func=on  computes  a  fresh  random  output.  
  • 22. #ESCBOS Implemen6ng:  HMAC-­‐DRBG  (3) The  Reseed  func=on  restarts  the  DRBG  with  fresh  entropy  data.    
  • 23. #ESCBOS Implemen6ng:  Entropy  Source We  need  uncorrelated  noise   sources  as  the  source  of  entropy.     All  the  ADC  analog  sensors  lower   bits  are  used  as  noise  sources.     The  noise  is  de-­‐biased  through  a   Von  Neumann  de-­‐bias  filter,  and   collected  into  a  2048bit     entropy  pool.  
  • 24. #ESCBOS Implemen6ng:  Entropy  Source  (2) The  entropy  source  takes  960bits  of  noise  data  and  applies  2  parallel   HMAC  condi=oning  func=ons,  using  the  CPU  chip  SN  as  the  key.     This  produces  very  high  quality,  very  high  entropy  seed  material.  
  • 25. #ESCBOS Implemen6ng:  Entropy  Source  (3) The  entropy  source  also  produces  high  quality  cryptographic  nonces.    
  • 26. #ESCBOS Implemen6ng:  (N)RBG When  you  add  a  ‘live’  entropy  source  to  an  instan=ated  HMAC-­‐DRBG,   that  is  con=nuously  reseeded  with  fresh,  high-­‐entropy  data,  you  get  a   NRBG  (Non-­‐Determinis=c  Random  Bit  Generator),  or  an  approved   True  Random  Number  Generator  !     This  is  a  fast,  high-­‐quality  keying  material  generator  for  the  system.   Entropy! Source! HMAC! DRBG! NOISE! SRC! continuous! reseed! high quality TRNG (!) ! 2048   bit   Pool  
  • 27. #ESCBOS Digital  Signatures:  ATECC108A Ellip=c  Curves  DSA  (ECDSA)  is  one  of  the  strongest  public-­‐key   cryptographic  signature  algorithms  today.       One  problem  is  that  it  is  expensive  to  implement  in  a  microcontroller.     We  selected  a  cer=fied,  external  ECDSA  accelerator  that  also  works   as  a  secure  EEPROM  to  store  the  private  keys,  increasing  system   compliance  to  FIPS-­‐140-­‐2  level  2  and  3.       The  device  is  the  Atmel  (now  Microchip)  ATECC108A.     We  designed  the  ECDSA  sign/verify  as  a  system  service  around  the   crypto  memory.  
  • 28. #ESCBOS Digital  Signatures:  ATECC108A  (2) The  driver  takes  the  chip  out  of  IDLE  state  (chip  wake  up)    
  • 29. #ESCBOS Digital  Signatures:  ATECC108A  (3) The  command  executes  in  the  BUSY  state.  The  chip  is  unresponsive   during  BUSY.    
  • 30. #ESCBOS Digital  Signatures:  ATECC108A  (4) Aaer  the  command  returns,  the  chip  is  placed  in  IDLE  again.    
  • 31. #ESCBOS Digital  Signatures:  ATECC108A  (5) The  actual  driver  code   accounts  for  every   possible  error  and  bus   =meout.  
  • 32. #ESCBOS Implemen6ng:  ECDSA  Sign/Verify Lib  Interface:     /**  Descriptor  for  ECC  sign/verify  operations.  */   typedef  struct  ecdsa_vector_t  {          LAP_TIMER64_T  lap_timer64;                                    //!<  64  bit  lap  timer  for  this  operation          ECC_KEY_TYPES_T  key_type;                                      //!<  Key  type,  curve  and  key  storage          uint32_t  slot  :  8;                                                    //!<  Key  slot  for  internal  keys          uint32_t  key_length;                                                //!<  public  key  data  length          uint32_t  signature_length;                                    //!<  signature  data  length            uint8_t  *msg_hash;                                                    //!<  ptr  to  the  32-­‐byte  Message  hash  (SHA-­‐256)          uint8_t  *key_data;                                                    //!<  ptr  to  the  External  Key  buffer          uint8_t  *signature;                                                  //!<  ptr  to  the  Signature  buffer  generated  by  ecdsa_sign()   }  ECDSA_VECTOR_T;     SECURE_STATUS_T  ecdsa_sign(ECDSA_VECTOR_T  *vector,  ECDSA_CMD_EVENT_T  *event);   SECURE_STATUS_T  ecdsa_verify(ECDSA_VECTOR_T  *vector,  ECDSA_CMD_EVENT_T  *event);    
  • 33. #ESCBOS RAM  secureFence One  of  the  services  available  is  the  secureFence  service.     Applica=ons  can  request  that  certain  structs  be  locked  as  immutable  data.     The  structs  are  signed  with  a  random  key  and  checked  every  system  pass.     hXp://i2.wp.com/patriot-­‐tech.com/wp-­‐content/uploads/2014/06/SCADA_security.jpg   If  the  struct  is  modified  by  unauthorized  code  or   wild  pointers,  the  service  generates  a  FAULT,  and   the  system  is  reset.   It  effec=vely  places  a  crypto  fence  around  system   sensi=ve  data,  such  as  calibra=on  constants  and   measurement  results.        
  • 34. #ESCBOS RAM  secureFence  (2)  //  -­‐-­‐-­‐  register  secureFence  service  -­‐-­‐-­‐          if(!register_struct_as_secure(                          &(SECURE_MEM_PARAMETERS_T){                                  .struct_ptr                  =  &weighing_setup,                                  .struct_size                =  sizeof(weighing_setup),                                  .str_struct_name        =  "weighing_setup{}"},                          &weighing_data.secure)          )      throw_app_fault(__FUNCTION__,  ":  error  registering  secure  struct.");     static  WEIGHING_ERROR_T  set_adc_sampling_rate(float  rate_sps)   {          WEIGHING_ERROR_T  status;                    weighing_data.secure.open();                                                                                        //  open  vault:  allow  modifications          status  =  adc-­‐>set_sampling_rate(rate_sps);          weighing_setup.sampling_rate  =  adc-­‐>get_sampling_rate();          status  =  weighing_data.persistent.save()  ?  status  :  ADC_ERR_FAILURE;          weighing_data.secure.close();                                                                                      //  secure  vault:  protect  data                    return  status;   }    
  • 35. #ESCBOS Tamper  and  Fraud  detec6on SHA-­‐256   HMAC   DRBG   True  RNG   ECDSA  SIGN  /  VERIFY   Key  Gen/KDF   BASE64   CRC16   CRC32   CryptoSeal   X.509   RAM  secureFence   Passwd   SecureDB   Public  Key  Cryptography     User  Authen=ca=on   Secure  LOGs   RAM  Tamper  Detec=on   Calibra=on  Crypto  Seal   Fast  hash  func=ons   High-­‐quality  Keys   PKI  Cer=ficates  
  • 36. #ESCBOS Thank  you   Jonny  Doin   jonnydoin@gridvortex.com