Esempio n. 1
0
void crypto_sha_getinternstate(unsigned char output[], size_t olen)
{
    uint32_t *in_pos = (uint32_t *) &CRPT->SHA_DGST0;
    unsigned char *out_pos = output;
    uint32_t rmn = olen;
    
    while (rmn) {
        uint32_t val = *in_pos ++;
        nu_set32_be(out_pos, val);
        out_pos += 4;
        rmn -= 4;
    }
}
Esempio n. 2
0
static int mbedtls_des_docrypt(uint16_t keyopt, uint8_t key[3][MBEDTLS_DES_KEY_SIZE], int enc, uint32_t tdes_opmode, size_t length, 
    unsigned char iv[8], const unsigned char *input, unsigned char *output)
{
    if (length % 8) {
        return MBEDTLS_ERR_DES_INVALID_INPUT_LENGTH;
    }
    
    // NOTE: Don't call driver function TDES_Open in BSP because it doesn't support TDES_CTL[3KEYS] setting.
    CRPT->TDES_CTL = (0 << CRPT_TDES_CTL_CHANNEL_Pos) | (enc << CRPT_TDES_CTL_ENCRPT_Pos) |
        tdes_opmode | (TDES_IN_OUT_WHL_SWAP << CRPT_TDES_CTL_BLKSWAP_Pos);

    // Keying option 1: All three keys are independent.
    // Keying option 2: K1 and K2 are independent, and K3 = K1.
    // Keying option 3: All three keys are identical, i.e. K1 = K2 = K3. 
    if (keyopt == 1) {
        CRPT->TDES_CTL |= CRPT_TDES_CTL_3KEYS_Msk;
    }
    else {
        CRPT->TDES_CTL &= ~CRPT_TDES_CTL_3KEYS_Msk;
    }

    // Set DES/TDES keys
    // NOTE: Don't call driver function TDES_SetKey in BSP because it doesn't support endian swap.
    uint32_t val;
    volatile uint32_t *tdes_key = (uint32_t *) ((uint32_t) &CRPT->TDES0_KEY1H + (0x40 * 0));
    val = nu_get32_be(key[0] + 0);
    *tdes_key ++ = val;
    val = nu_get32_be(key[0] + 4);
    *tdes_key ++ = val;
    val = nu_get32_be(key[1] + 0);
    *tdes_key ++ = val;
    val = nu_get32_be(key[1] + 4);
    *tdes_key ++ = val;
    val = nu_get32_be(key[2] + 0);
    *tdes_key ++ = val;
    val = nu_get32_be(key[2] + 4);
    *tdes_key ++ = val;
    
    uint32_t rmn = length;
    const unsigned char *in_pos = input;
    const unsigned char *out_pos = output;
    
    while (rmn) {
        uint32_t data_len = (rmn <= MAXSIZE_DMABUF) ? rmn : MAXSIZE_DMABUF;
        
        uint32_t ivh, ivl;
        ivh = nu_get32_be(iv);
        ivl = nu_get32_be(iv + 4);
        TDES_SetInitVect(0, ivh, ivl);
    
        memcpy(dmabuf_in, in_pos, data_len);
        
        TDES_SetDMATransfer(0, (uint32_t) dmabuf_in, (uint32_t) dmabuf_out, data_len);
        
        // Start enc/dec.
        // NOTE: Don't call driver function TDES_Start in BSP because it will override TDES_CTL[3KEYS] setting.
        CRPT->TDES_CTL |= CRPT_TDES_CTL_START_Msk | (CRYPTO_DMA_ONE_SHOT << CRPT_TDES_CTL_DMALAST_Pos);
        while (CRPT->TDES_STS & CRPT_TDES_STS_BUSY_Msk);
        
        memcpy(out_pos, dmabuf_out, data_len);
        in_pos += data_len;
        out_pos += data_len;
        rmn -= data_len;
        
        // Update IV for next block enc/dec in next function call
        switch (tdes_opmode) {
            case DES_MODE_OFB:
            case TDES_MODE_OFB: {
                // OFB: IV (enc/dec) = output block XOR input block
                uint32_t lbh, lbl;
                // Last block of input data
                lbh = nu_get32_be(dmabuf_in + data_len - 8 + 4);
                lbl = nu_get32_be(dmabuf_in + data_len - 8 + 0);
                // Last block of output data
                ivh = nu_get32_be(dmabuf_out + 4);
                ivl = nu_get32_be(dmabuf_out + 0);
                ivh = ivh ^ lbh;
                ivl = ivl ^ lbl;
                nu_set32_be(iv + 4, ivh);
                nu_set32_be(iv, ivl);
                break;
            }
            case DES_MODE_CBC:
            case DES_MODE_CFB:
            case TDES_MODE_CBC:
            case TDES_MODE_CFB: {
                // CBC/CFB: IV (enc) = output block
                //          IV (dec) = input block
                if (enc) {    
                    memcpy(iv, dmabuf_out + data_len - 8, 8);
                }
                else {
                    memcpy(iv, dmabuf_in + data_len - 8, 8);
                }
            }
        }
    }
    
    return 0;
}