code stringlengths 1 1.05M | repo_name stringlengths 6 83 | path stringlengths 3 242 | language stringclasses 222 values | license stringclasses 20 values | size int64 1 1.05M |
|---|---|---|---|---|---|
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
#include "poly1305_x86_64.S"
.file "poly1305_x86_64_avx2.S"
.text
/**
* Function description: This function is implemented by x86_64 poly1305. The result is stored in ctx->acc.
* Function prototype: uint32_t Poly1305Block(Poly1305_Ctx *ctx, const uint8_t *data,
* uint32_t dataLen, uint32_t padbit);
* Input register:
* CTX: address of the Poly305_Ctx structure
* INP: pointer to the input data
* LEN: length of the input data
* PADBIT: padding bit, 0 or 1.
* Change registers: r8-r14, rbx, rbp
* Output register:
* %rax: length of the remaining data to be processed
* Function/Macro Call:Poly1305_MOD_MUL
*/
.globl Poly1305Block
.type Poly1305Block,@function
Poly1305Block:
.cfi_startproc
.align 32
cmp $256, LEN
jae .Lblock_avx_pre
jmp Poly1305Block64Bit
.Lblock_avx_pre:
andq $-16, LEN
test $63, LEN
jz Poly1305BlockAVX2
.Lbase2_64_avx_body:
push %rbx
push %rbp
push %r12
push %r13
push %r14
push %r15
movq LEN, %r15
LOAD_ACC_R CTX, R0, R1, R2, ACC1, ACC2, ACC3, %r8d, %rax
test %r8d, %r8d
jz .Lbase2_64_avx_loop
CONVERT_26TO64_PRE ACC1, ACC2, D1, D2, D3
CONVERT_26TO64 ACC1, D1, ACC2, D2, D3, ACC3
movl $0, 220(CTX)
.align 32
.Lbase2_64_avx_loop:
addq (INP), ACC1
adcq 8(INP), ACC2
adcq PADBIT, ACC3
lea 16(INP), INP
POLY1305_MOD_MUL ACC1, ACC2, ACC3, R0, R1, R2
subq $16, %r15
movq R1, %rax
test $63, %r15
jnz .Lbase2_64_avx_loop
movq ACC1, (CTX)
movq ACC2, 8(CTX)
movq ACC3, 16(CTX)
movq %r15, LEN
pop %r15
pop %r14
pop %r13
pop %r12
pop %rbp
pop %rbx
jmp Poly1305BlockAVX2
ret
.cfi_endproc
.size Poly1305Block, .-Poly1305Block
/**
* Function description: x86_64 poly1305 AVX2 implementation
* Input register:
* CTX: address of the Poly305_Ctx structure
* INP: pointer to the input data
* LEN: length of the input data
* PADBIT: padding bit, 0 or 1.
* Change register: ymm0-15, r8, r9, r14, r15, rax, rbx, rdx, rbp
* Output register:
* rax: length of the remaining data to be processed
* Function/Macro Call:
* CONVERT_64TO26
*/
.globl Poly1305BlockAVX2
.type Poly1305BlockAVX2, @function
.align 32
Poly1305BlockAVX2:
.cfi_startproc
push %rbx
push %rbp
push %r14
push %r15
vzeroupper
movq (CTX), ACC1 // load acc
movq 8(CTX), ACC2
movq 16(CTX), ACC3
movl 220(CTX), %r8d
test %r8d, %r8d
jnz .Lblock_avx2_pre
movq LEN, %r15
CONVERT_64TO26 ACC1, ACC2, ACC3, %rax, %rdx // base2_64 --> base2_26
movq %r15, LEN
jmp .Lblock_avx2_body
.Lblock_avx2_pre:
movd %r14, %xmm0
movd %rbx, %xmm2
movd %rbp, %xmm4
shrq $32, %r14
shrq $32, %rbx
movd %r14, %xmm1
movd %rbx, %xmm3
.align 32
.Lblock_avx2_body:
leaq 56(CTX), CTX // 56(CTX)
vmovdqu g_permd_avx2(%rip), YT0 // g_permd_avx2
leaq -8(%rsp), %r11
/* Transform the content in the precomputation table into a computable form and put it into the stack. */
vmovdqu (CTX), %xmm7
vmovdqu 16(CTX), %xmm8
subq $0x128, %rsp
vmovdqu 32(CTX), %xmm9
vmovdqu 48(CTX), %xmm11
andq $-512, %rsp
vmovdqu 64(CTX), %xmm12
vmovdqu 80(CTX), %xmm13
vpermd YT2, YT0, YT2 // 00 00 34 12 --> 14 24 34 44
vmovdqu 96(CTX), %xmm14
vpermd YT3, YT0, YT3
vmovdqu 112(CTX), %xmm15
vpermd YT4, YT0, YT4
vmovdqu 128(CTX), %xmm10
vpermd YB0, YT0, YB0
vmovdqa YT2, (%rsp) // r0
vpermd YB1, YT0, YB1
vmovdqa YT3, 0x20(%rsp) // r1
vpermd YB2, YT0, YB2
vmovdqa YT4, 0x40(%rsp) // s1
vpermd YB3, YT0, YB3
vmovdqa YB0, 0x60(%rsp) // r2
vpermd YB4, YT0, YB4
vmovdqa YB1, 0x80(%rsp) // s2
vpermd YMASK, YT0, YMASK
vmovdqa YB2, 0xa0(%rsp) // r3
vmovdqa YB3, 0xc0(%rsp) // s3
vmovdqa YB4, 0xe0(%rsp) // r4
vmovdqa YMASK, 0x100(%rsp) // s4
/* Load 4 blocks of data and convert them to base2_26 */
vmovdqu g_mask26(%rip), YMASK // g_mask26
vmovdqu (INP), %xmm5
vmovdqu 16(INP), %xmm6
vinserti128 $1, 32(INP), YT0, YT0
vinserti128 $1, 48(INP), YT1, YT1
leaq 64(INP), INP
vpsrldq $6, YT0, YT2
vpsrldq $6, YT1, YT3
vpunpckhqdq YT1, YT0, YT4
vpunpcklqdq YT1, YT0, YT0
vpunpcklqdq YT3, YT2, YT2
vpsrlq $26, YT0, YT1
vpsrlq $30, YT2, YT3
vpsrlq $4, YT2, YT2
vpsrlq $40, YT4, YT4 // 4
vpand YMASK, YT3, YT3 // 3
vpand YMASK, YT2, YT2 // 2
vpor g_129(%rip), YT4, YT4 // padbit
vpand YMASK, YT1, YT1 // 1
vpand YMASK, YT0, YT0 // 0
vpaddq YH2, YT2, YH2
sub $64, LEN
jz .Lblock_avx2_tail
jmp .Lblock_avx2_loop
.align 32
.Lblock_avx2_loop:
// ((inp[0]*r^4 + inp[4])*r^4 + inp[ 8])*r^4
// ((inp[1]*r^4 + inp[5])*r^4 + inp[ 9])*r^3
// ((inp[2]*r^4 + inp[6])*r^4 + inp[10])*r^2
// ((inp[3]*r^4 + inp[7])*r^4 + inp[11])*r^1
vpaddq YH0, YT0, YH0
vpaddq YH1, YT1, YH1
vpaddq YH3, YT3, YH3
vpaddq YH4, YT4, YH4
vmovdqa (%rsp), YT0 // r0^4
vmovdqa 0x20(%rsp), YT1 // r1^4
vmovdqa 0x60(%rsp), YT2 // r2^4
vmovdqa 0xc0(%rsp), YT3 // s3^4
vmovdqa 0x100(%rsp), YMASK // s4^4
// b4 = h4*r0^4 + h3*r1^4 + h2*r2^4 + h1*r3^4 + h0*r4^4
// b3 = h3*r0^4 + h2*r1^4 + h1*r2^4 + h0*r3^4 + h4*s4^4
// b2 = h2*r0^4 + h1*r1^4 + h0*r2^4 + h4*s3^4 + h3*s4^4
// b1 = h1*r0^4 + h0*r1^4 + h4*s2^4 + h3*s3^4 + h2*s4^4
// b0 = h0*r0^4 + h4*s1^4 + h3*s2^4 + h2*s3^4 + h1*s4^4
//
// First calculate h2, the above formula can be deformed as
//
// b4 = h2*r2^4 + h4*r0^4 + h3*r1^4 + + h1*r3^4 + h0*r4^4
// b3 = h2*r1^4 + h3*r0^4 + + h1*r2^4 + h0*r3^4 + h4*s4^4
// b2 = h2*r0^4 + + h1*r1^4 + h0*r2^4 + h4*s3^4 + h3*s4^4
// b1 = h2*s4^4 + h1*r0^4 + h0*r1^4 + h4*s2^4 + h3*s3^4 +
// b0 = h2*s3^4 + h0*r0^4 + h4*s1^4 + h3*s2^4 + + h1*s4^4
vpmuludq YH2, YT0, YB2 // b2 = h2 * r0^4
vpmuludq YH2, YT1, YB3 // b3 = h2 * r1^4
vpmuludq YH2, YT2, YB4 // b4 = h2 * r2^4
vpmuludq YH2, YT3, YB0 // b0 = h2 * s3^4
vpmuludq YH2, YMASK, YB1 // b1 = h2 * s4^4
vpmuludq YH1, YT1, YT4 // h1 * r1^4 (Available Scratch Registers：T4、H2)
vpmuludq YH0, YT1, YH2 // h0 * r1^4
vpaddq YT4, YB2, YB2 // b2 += h1 * r1^4
vpaddq YH2, YB1, YB1 // b1 += h0 * r1^4
vpmuludq YH3, YT1, YT4 // h3 * r1^4
vpmuludq 0x40(%rsp), YH4, YH2 // h4 * s1^4
vpaddq YT4 ,YB4, YB4 // b4 += h3 * r1^4
vpaddq YH2, YB0, YB0 // b0 += h4 * s1^4
vmovdqa 0x80(%rsp), YT1 // load s2^4
vpmuludq YH4, YT0, YT4 // h4 * r0^4 (Available Scratch Registers：T4、H2)
vpmuludq YH3, YT0, YH2 // h3 * r0^4
vpaddq YT4, YB4, YB4 // b4 += h4 * r0^4
vpaddq YH2, YB3, YB3 // b3 += h3 * r0^4
vpmuludq YH0, YT0, YT4 // h0 * r0^4
vpmuludq YH1, YT0, YH2 // h1 * r0^4
vpaddq YT4, YB0, YB0 // b0 += h0 * r0^4
vpaddq YH2, YB1, YB1 // b1 += h1 * r0^4
vmovdqu (INP), %xmm5 // load input (YT0)
vpmuludq YH4, YT1, YT4 // h4 * s2^4
vpmuludq YH3, YT1, YH2 // h3 * s2^4
vinserti128 $1, 32(INP), YT0, YT0
vpaddq YT4, YB1, YB1 // b1 += h4 * s2^4
vpaddq YH2, YB0, YB0 // b0 += h3 * s2^4
vpmuludq YH1, YT2, YT4 // h1 * r2^4 (Available Scratch Registers：T4、H2)
vpmuludq YH0, YT2, YH2 // h0 * r2^4
vmovdqu 16(INP), %xmm6 // load input (YT1)
vpaddq YT4, YB3, YB3 // b3 += h1 * r2^4
vpaddq YH2, YB2, YB2 // b2 += h0 * r2^4
vinserti128 $1, 48(INP), YT1, YT1
vmovdqa 0xa0(%rsp), YH2 // load r3^4
leaq 64(INP), INP
vpmuludq YH1, YH2, YT4 // h1 * r3^4 (Available Scratch Registers：T4、H2)
vpmuludq YH0, YH2, YH2 // h0 * r3^4
vpsrldq $6, YT0, YT2
vpaddq YT4, YB4, YB4 // b4 += h1 * r3^4
vpaddq YH2, YB3, YB3 // b3 += h0 * r3^4
vpmuludq YH4, YT3, YT4 // h4 * s3^4
vpmuludq YH3, YT3, YH2 // h3 * s3^4
vpsrldq $6, YT1, YT3
vpaddq YT4, YB2, YB2 // b2 += h4 * s3^4
vpaddq YH2, YB1, YB1 // b1 += h3 * s3^4 (finish)
vpunpckhqdq YT1, YT0, YT4
vpmuludq YH3, YMASK, YH3 // h3 * s4^4
vpmuludq YH4, YMASK, YH4 // h4 * s4^4
vpunpcklqdq YT1, YT0, YT0
vpaddq YB2, YH3, YH2 // h2 += h3 * s4^4 (finish)
vpaddq YB3, YH4, YH3 // h3 += h4 * s4^4 (finish)
vpunpcklqdq YT3, YT2, YT3
vpmuludq 0xe0(%rsp), YH0, YH4 // h0 * r4^4
vpmuludq YH1, YMASK, YH0 // h1 * s4^4
vmovdqu g_mask26(%rip), YMASK
vpaddq YH4, YB4, YH4 // h4 += h0 * r4^4 (finish)
vpaddq YH0, YB0, YH0 // h0 += h1 * s4^4 (finish)
// reduction
vpsrlq $26, YH3, YB3
vpand YMASK, YH3, YH3
vpaddq YB3, YH4, YH4 // h3 -> h4
vpsrlq $26, YH0, YB0
vpand YMASK, YH0, YH0
vpaddq YB0, YB1, YH1 // h0 -> h1
vpsrlq $26, YH4, YB4
vpand YMASK, YH4, YH4
vpsrlq $4, YT3, YT2
vpsrlq $26, YH1, YB1
vpand YMASK, YH1, YH1
vpaddq YB1, YH2, YH2 // h1 -> h2
vpaddq YB4, YH0, YH0
vpsllq $2, YB4, YB4
vpaddq YB4, YH0, YH0 // h4 -> h0
vpand YMASK, YT2, YT2
vpsrlq $26, YT0, YT1
vpsrlq $26, YH2, YB2
vpand YMASK, YH2, YH2
vpaddq YB2, YH3, YH3 // h2 -> h3
vpaddq YT2, YH2, YH2 // prepare next 4 block
vpsrlq $30, YT3, YT3
vpsrlq $26, YH0, YB0
vpand YMASK, YH0, YH0
vpaddq YB0, YH1, YH1 // h0 -> h1
vpsrlq $40, YT4, YT4
vpsrlq $26, YH3, YB3
vpand YMASK, YH3, YH3
vpaddq YB3, YH4, YH4 // h3 -> h4
vpand YMASK, YT0, YT0 // new input 0
vpand YMASK, YT1, YT1 // new input 1
vpand YMASK, YT3, YT3 // new input 3
vpor g_129(%rip), YT4, YT4 // new input 4, padbit
subq $64, LEN
jnz .Lblock_avx2_loop
.Lblock_avx2_tail:
BLOCK4_AVX2_TAIL YT0, YT1, YT2, YT3, YT4, YH0, YH1, YH2, YH3, YH4, YB0, YB1, YB2, YB3, YB4, YMASK, %rsp
vmovd %xmm0, -56(CTX)
vmovd %xmm1, -52(CTX)
vmovd %xmm2, -48(CTX)
vmovd %xmm3, -44(CTX)
vmovd %xmm4, -40(CTX)
vzeroupper
leaq 8(%r11), %rsp
pop %r15
pop %r14
pop %rbp
pop %rbx
movq LEN, %rax
ret
.cfi_endproc
.size Poly1305BlockAVX2, .-Poly1305BlockAVX2
/**
* Function description: This function is used to clear residual sensitive information in a register.
* Function prototype: void Poly1305CleanRegister();
*/
.globl Poly1305CleanRegister
.type Poly1305CleanRegister, @function
Poly1305CleanRegister:
.cfi_startproc
vzeroall
ret
.cfi_endproc
.size Poly1305CleanRegister, .-Poly1305CleanRegister
#endif
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm/poly1305_x86_64_avx2.S | Unix Assembly | unknown | 13,801 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
#include "poly1305_x86_64.S"
.file "poly1305_x86_64_avx512.S"
.text
.set ZH0, %zmm0
.set ZH1, %zmm1
.set ZH2, %zmm2
.set ZH3, %zmm3
.set ZH4, %zmm4
.set ZT0, %zmm5
.set ZT1, %zmm6
.set ZT2, %zmm7
.set ZT3, %zmm8
.set ZT4, %zmm9
.set ZMASK, %zmm10
.set ZB0, %zmm11
.set ZB1, %zmm12
.set ZB2, %zmm13
.set ZB3, %zmm14
.set ZB4, %zmm15
.set ZR0, %zmm16
.set ZR1, %zmm17
.set ZR2, %zmm18
.set ZR3, %zmm19
.set ZR4, %zmm20
.set ZS1, %zmm21
.set ZS2, %zmm22
.set ZS3, %zmm23
.set ZS4, %zmm24
.set ZM0, %zmm25
.set ZM1, %zmm26
.set ZM2, %zmm27
.set ZM3, %zmm28
.set ZM4, %zmm29
.set PADBIT_ZMM, %zmm30
.align 64
g_permd_avx512:
.long 0, 0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7
.size g_permd_avx512, .-g_permd_avx512
/**
* Function description: This function is implemented by x86_64 poly1305. The result is stored in ctx->acc.
* Function prototype: uint32_t Poly1305Block(Poly1305_Ctx *ctx, const uint8_t *data, uint32_t dataLen, uint32_t padbit);
* Input register:
* CTX: address of the Poly305_Ctx structure
* INP: pointer to the input data
* LEN: length of the input data
* PADBIT: padding bit, 0 or 1.
* Change register: r8-r15, rbx, rbp, rdx, rax
* Output register:
* %rax: length of the remaining data to be processed
* Function/Macro Call: Poly1305_MOD_MUL
*/
.globl Poly1305Block
.type Poly1305Block, @function
Poly1305Block:
.cfi_startproc
.align 32
cmp $256, LEN
jae .Lblock_avx_pre
call Poly1305Block64Bit
ret
.Lblock_avx_pre:
andq $-16, LEN
test $63, LEN
jz Poly1305BlockAVX512
.Lbase2_64_avx_body:
push %rbx
push %rbp
push %r12
push %r13
push %r14
push %r15
movq LEN, %r15
movq (CTX), ACC1 // load acc
LOAD_ACC_R CTX, R0, R1, R2, ACC1, ACC2, ACC3, %r8d, %rax
test %r8d, %r8d
jz .Lbase2_64_avx_loop
CONVERT_26TO64_PRE ACC1, ACC2, D1, D2, D3
CONVERT_26TO64 ACC1 D1, ACC2, D2, D3, ACC3
movl $0, 220(CTX)
.align 32
.Lbase2_64_avx_loop:
addq (INP), ACC1
adcq 8(INP), ACC2
adcq PADBIT, ACC3
lea 16(INP), INP
POLY1305_MOD_MUL ACC1, ACC2, ACC3, R0, R1, R2
subq $16, %r15
test $63, %r15
movq R1, %rax
jnz .Lbase2_64_avx_loop
movq ACC1, (CTX)
movq ACC2, 8(CTX)
movq ACC3, 16(CTX)
movq %r15, LEN
pop %r15
pop %r14
pop %r13
pop %r12
pop %rbp
pop %rbx
jmp Poly1305BlockAVX512
ret
.cfi_endproc
.size Poly1305Block, .-Poly1305Block
/**
* Function description: x86_64 poly1305 AVX512 assembly acceleration implementation
* Input register:
* CTX: address of the Poly305_Ctx structure
* INP: pointer to the input data
* LEN: length of the input data
* PADBIT: padding bit, 0 or 1.
* Change register: zmm0-31, rax, rsp, r11, rcx, rdi, k1-k3
* Output register:
* rax: length of the remaining data to be processed
* Function/Macro Call:
* CONVERT_64TO26
*/
.globl Poly1305BlockAVX512
.type Poly1305BlockAVX512, @function
.align 32
Poly1305BlockAVX512:
.cfi_startproc
push %rbx
push %rbp
push %r12
push %r13
push %r14
push %r15
vzeroupper
movq (CTX), ACC1
movq 8(CTX), ACC2
movq 16(CTX), ACC3
movl 220(CTX), %r8d
test %r8d, %r8d
jnz .Lblock_avx512_pre
movq LEN, %r15
CONVERT_64TO26 ACC1, ACC2, ACC3, %rax, %rdx
movq %r15, LEN
jmp .Lblock_avx512_body
.Lblock_avx512_pre:
movd %r14, %xmm0
movd %rbx, %xmm2
shrq $32, %r14
shrq $32, %rbx
movd %r14, %xmm1
movd %rbx, %xmm3
movd %rbp, %xmm4
.Lblock_avx512_body:
movl $15, %eax
kmovw %eax, %k2
leaq -8(%rsp), %r11
subq $0x128, %rsp
leaq 56(CTX), CTX
vmovdqa g_permd_avx2(%rip), YT2 // g_permd_avx2
// Extend the precomputation table to the power of 8
andq $-512, %rsp
movq $0x20, %rax
vmovdqu (CTX), %xmm11
vmovdqu 16(CTX), %xmm12
vmovdqu 32(CTX), %xmm5
vmovdqu 48(CTX), %xmm13
vmovdqu 64(CTX), %xmm6
vmovdqu 80(CTX), %xmm14
vpermd ZB0, ZT2, ZR0 // 00 00 34 12 -> 14 24 34 44
vmovdqu 96(CTX), %xmm8
vpbroadcastq g_mask26(%rip), ZMASK // g_mask26
vmovdqu 112(CTX), %xmm15
vpermd ZB1, ZT2, ZR1
vmovdqu 128(CTX), %xmm9
vpermd ZT0, ZT2, ZS1
vpermd ZB2, ZT2, ZR2
vmovdqa64 ZR0, (%rsp){%k2}
vpsrlq $32, ZR0, ZT0 // 14 24 34 44 -> 01 02 03 04
vpermd ZT1, ZT2, ZS2
vmovdqu64 ZR1, (%rsp, %rax){%k2}
vpsrlq $32, ZR1, ZT1
vpermd ZB3, ZT2, ZR3
vmovdqa64 ZS1, 0x40(%rsp){%k2}
vpermd ZT3, ZT2, ZS3
vmovdqu64 ZR2, 0x40(%rsp, %rax){%k2}
vpermd ZB4, ZT2, ZR4
vmovdqa64 ZS2, 0x80(%rsp){%k2}
vpermd ZT4, ZT2, ZS4
vmovdqu64 ZR3, 0x80(%rsp, %rax){%k2}
vmovdqa64 ZS3, 0xc0(%rsp){%k2}
vmovdqu64 ZR4, 0xc0(%rsp, %rax){%k2}
vmovdqa64 ZS4, 0x100(%rsp){%k2}
vpmuludq ZT0, ZR0, ZB0
vpmuludq ZT0, ZR1, ZB1
vpmuludq ZT0, ZR2, ZB2
vpmuludq ZT0, ZR3, ZB3
vpmuludq ZT0, ZR4, ZB4
vpsrlq $32, ZR2, ZT2
vpmuludq ZT1, ZS4, ZM0
vpmuludq ZT1, ZR0, ZM1
vpmuludq ZT1, ZR1, ZM2
vpmuludq ZT1, ZR2, ZM3
vpmuludq ZT1, ZR3, ZM4
vpsrlq $32, ZR3, ZT3
vpaddq ZM0, ZB0, ZB0
vpaddq ZM1, ZB1, ZB1
vpaddq ZM2, ZB2, ZB2
vpaddq ZM3, ZB3, ZB3
vpaddq ZM4, ZB4, ZB4
vpmuludq ZT2, ZS3, ZM0
vpmuludq ZT2, ZS4, ZM1
vpmuludq ZT2, ZR0, ZM2
vpmuludq ZT2, ZR1, ZM3
vpmuludq ZT2, ZR2, ZM4
vpsrlq $32, ZR4, ZT4
vpaddq ZM0, ZB0, ZB0
vpaddq ZM1, ZB1, ZB1
vpaddq ZM2, ZB2, ZB2
vpaddq ZM3, ZB3, ZB3
vpaddq ZM4, ZB4, ZB4
vpmuludq ZT3, ZS2, ZM0
vpmuludq ZT3, ZS3, ZM1
vpmuludq ZT3, ZS4, ZM2
vpmuludq ZT3, ZR0, ZM3
vpmuludq ZT3, ZR1, ZM4
vpaddq ZM0, ZB0, ZB0
vpaddq ZM1, ZB1, ZB1
vpaddq ZM2, ZB2, ZB2
vpaddq ZM3, ZB3, ZB3
vpaddq ZM4, ZB4, ZB4
vpmuludq ZT4, ZS1, ZM0
vpmuludq ZT4, ZS2, ZM1
vpmuludq ZT4, ZS3, ZM2
vpmuludq ZT4, ZS4, ZM3
vpmuludq ZT4, ZR0, ZM4
vpaddq ZM0, ZB0, ZB0
vpaddq ZM1, ZB1, ZB1
vpaddq ZM2, ZB2, ZB2
vpaddq ZM3, ZB3, ZB3
vpaddq ZM4, ZB4, ZB4
// reduction
vpsrlq $26, ZB3, ZM3
vpandq ZMASK, ZB3, ZB3
vpaddq ZM3, ZB4, ZB4 // d3 -> d4
vpsrlq $26, ZB0, ZM0
vpandq ZMASK, ZB0, ZB0
vpaddq ZM0, ZB1, ZB1 // d0 -> d1
vpsrlq $26, ZB4, ZM4
vpandq ZMASK, ZB4, ZB4
vmovdqu64 (INP), ZT3
vmovdqu64 64(INP), ZT4
leaq 128(INP), INP
vpsrlq $26, ZB1, ZM1
vpandq ZMASK, ZB1, ZB1
vpaddq ZM1, ZB2, ZB2 // d1 -> d2
vpaddq ZM4, ZB0, ZB0
vpsllq $2, ZM4, ZM4
vpaddq ZM4, ZB0, ZB0 // d4 -> d0
vpsrlq $26, ZB2, ZM2
vpandq ZMASK, ZB2, ZB2
vpaddq ZM2, ZB3, ZB3 // d2 -> d3
vpsrlq $26, ZB0, ZM0
vpandq ZMASK, ZB0, ZB0
vpaddq ZM0, ZB1, ZB1 // d0 -> d1
vpsrlq $26, ZB3, ZM3
vpandq ZMASK, ZB3, ZB3
vpaddq ZM3, ZB4, ZB4 // d3 -> d4
vpunpcklqdq ZT4, ZT3, ZT0
vpunpckhqdq ZT4, ZT3, ZT4
// Construct R and S to make them in operable form.
vmovdqu32 g_permd_avx512(%rip), ZM0 // g_permd_avx512
movl $0x7777, %eax
kmovw %eax, %k1
vpermd ZR0, ZM0, ZR0 // 14 24 34 44 -> 1444 2444 3444 4444
vpermd ZR1, ZM0, ZR1
vpermd ZR2, ZM0, ZR2
vpermd ZR3, ZM0, ZR3
vpermd ZR4, ZM0, ZR4
vpermd ZB0, ZM0, ZR0{%k1} // 05 06 07 08 and 1444 2444 3444 4444 -> 1858 2868 3878 4888
vpermd ZB1, ZM0, ZR1{%k1}
vpermd ZB2, ZM0, ZR2{%k1}
vpermd ZB3, ZM0, ZR3{%k1}
vpermd ZB4, ZM0, ZR4{%k1}
vpslld $2, ZR1, ZS1
vpslld $2, ZR2, ZS2
vpslld $2, ZR3, ZS3
vpslld $2, ZR4, ZS4
vpaddd ZR1, ZS1, ZS1
vpaddd ZR2, ZS2, ZS2
vpaddd ZR3, ZS3, ZS3
vpaddd ZR4, ZS4, ZS4
// Processes the input message block and constructs the operation form.
vpbroadcastq g_129(%rip), PADBIT_ZMM // g_129
vpsrlq $52, ZT0, ZT2
vpsllq $12, ZT4, ZT3
vporq ZT3, ZT2, ZT2
vpsrlq $26, ZT0, ZT1
vpsrlq $14, ZT4, ZT3
vpsrlq $40, ZT4, ZT4 // 4
vpandq ZMASK, ZT0, ZT0 // 0
vpandq ZMASK, ZT2, ZT2 // 2
vpaddq ZH2, ZT2, ZH2
subq $192, LEN
jbe .Lblock_avx512_tail
jmp .Lblock_avx512_loop
.align 32
.Lblock_avx512_loop:
// ((inp[0] * r^8 + inp[ 8]) * r^8 + inp[16]) * r^8
// ((inp[1] * r^8 + inp[ 9]) * r^8 + inp[17]) * r^7
// ((inp[2] * r^8 + inp[10]) * r^8 + inp[18]) * r^6
// ((inp[3] * r^8 + inp[11]) * r^8 + inp[19]) * r^5
// ((inp[4] * r^8 + inp[12]) * r^8 + inp[20]) * r^4
// ((inp[5] * r^8 + inp[13]) * r^8 + inp[21]) * r^3
// ((inp[6] * r^8 + inp[14]) * r^8 + inp[22]) * r^2
// ((inp[7] * r^8 + inp[15]) * r^8 + inp[23]) * r^1
// b3 = h2*r1 + h0*r3 + h1*r2 + h3*r0 + h4*5*r4
// b4 = h2*r2 + h0*r4 + h1*r3 + h3*r1 + h4*r0
// b0 = h2*5*r3 + h0*r0 + h1*5*r4 + h3*5*r2 + h4*5*r1
// b1 = h2*5*r4 + h0*r1 + h1*r0 + h3*5*r3 + h4*5*r2
// b2 = h2*r0 + h0*r2 + h1*r1 + h3*5*r4 + h4*5*r3
vpmuludq ZH2, ZR1, ZB3
vpandq ZMASK, ZT1, ZT1 // 1
vpmuludq ZH2, ZR2, ZB4
vpandq ZMASK, ZT3, ZT3 // 3
vpmuludq ZH2, ZS3, ZB0
vporq PADBIT_ZMM, ZT4, ZT4
vpmuludq ZH2, ZS4, ZB1
vpaddq ZH0, ZT0, ZH0
vpmuludq ZH2, ZR0, ZB2
vpaddq ZH1, ZT1, ZH1
vpaddq ZH3, ZT3, ZH3
vpaddq ZH4, ZT4, ZH4
vmovdqu64 (INP), ZT3
vmovdqu64 64(INP), ZT4
lea 128(INP), INP
vpmuludq ZH0, ZR3, ZM3
vpmuludq ZH0, ZR4, ZM4
vpmuludq ZH0, ZR0, ZM0
vpmuludq ZH0, ZR1, ZM1
vpaddq ZM3, ZB3, ZB3
vpaddq ZM4, ZB4, ZB4
vpaddq ZM0, ZB0, ZB0
vpaddq ZM1, ZB1, ZB1
vpmuludq ZH1, ZR2, ZM3
vpmuludq ZH1, ZR3, ZM4
vpmuludq ZH1, ZS4, ZM0
vpmuludq ZH0, ZR2, ZM2
vpaddq ZM3, ZB3, ZB3
vpaddq ZM4, ZB4, ZB4
vpaddq ZM0, ZB0, ZB0
vpaddq ZM2, ZB2, ZB2
vpunpcklqdq ZT4, ZT3, ZT0
vpunpckhqdq ZT4, ZT3, ZT4
vpmuludq ZH3, ZR0, ZM3
vpmuludq ZH3, ZR1, ZM4
vpmuludq ZH1, ZR0, ZM1
vpmuludq ZH1, ZR1, ZM2
vpaddq ZM3, ZB3, ZB3
vpaddq ZM4, ZB4, ZB4
vpaddq ZM1, ZB1, ZB1
vpaddq ZM2, ZB2, ZB2
vpmuludq ZH4, ZS4, ZM3
vpmuludq ZH4, ZR0, ZM4
vpmuludq ZH3, ZS2, ZM0
vpmuludq ZH3, ZS3, ZM1
vpmuludq ZH3, ZS4, ZM2
vpaddq ZM3, ZB3, ZB3
vpaddq ZM4, ZB4, ZB4
vpaddq ZM0, ZB0, ZB0
vpaddq ZM1, ZB1, ZB1
vpaddq ZM2, ZB2, ZB2
vpmuludq ZH4, ZS1, ZM0
vpmuludq ZH4, ZS2, ZM1
vpmuludq ZH4, ZS3, ZM2
vpaddq ZM0, ZB0, ZH0
vpaddq ZM1, ZB1, ZH1
vpaddq ZM2, ZB2, ZH2
vpsrlq $52, ZT0, ZT2
vpsllq $12, ZT4, ZT3
// reduction
vpsrlq $26, ZB3, ZH3
vpandq ZMASK, ZB3, ZB3
vpaddq ZH3, ZB4, ZH4
vporq ZT3, ZT2, ZT2
vpsrlq $26, ZH0, ZB0
vpandq ZMASK, ZH0, ZH0
vpaddq ZB0, ZH1, ZH1
vpandq ZMASK, ZT2, ZT2
vpsrlq $26, ZH4, ZB4
vpandq ZMASK, ZH4, ZH4
vpsrlq $26, ZH1, ZB1
vpandq ZMASK, ZH1, ZH1
vpaddq ZB1, ZH2, ZH2
vpaddq ZB4, ZH0, ZH0
vpsllq $2, ZB4, ZB4
vpaddq ZB4, ZH0, ZH0
vpaddq ZT2, ZH2, ZH2
vpsrlq $26, ZT0, ZT1
vpsrlq $26, ZH2, ZB2
vpandq ZMASK, ZH2, ZH2
vpaddq ZB2, ZB3, ZH3
vpsrlq $14, ZT4, ZT3
vpsrlq $40, ZT4, ZT4
vpandq ZMASK, ZT0, ZT0
vpsrlq $26, ZH0, ZB0
vpandq ZMASK, ZH0, ZH0
vpaddq ZB0, ZH1, ZH1
vpsrlq $26, ZH3, ZB3
vpandq ZMASK, ZH3, ZH3
vpaddq ZB3, ZH4, ZH4
subq $128, LEN
ja .Lblock_avx512_loop
.align 32
.Lblock_avx512_tail:
vpsrlq $32, ZR0, ZR0 // 1858286838784888 -> 0105020603070408
vpsrlq $32, ZR1, ZR1
vpsrlq $32, ZS1, ZS1
vpsrlq $32, ZR2, ZR2
vpsrlq $32, ZS2, ZS2
vpsrlq $32, ZR3, ZR3
vpsrlq $32, ZS3, ZS3
vpsrlq $32, ZR4, ZR4
vpsrlq $32, ZS4, ZS4
lea (INP, LEN), INP
vpaddq ZH0, ZT0, ZH0
vpmuludq ZH2, ZR1, ZB3
vpandq ZMASK, ZT1, ZT1
vpmuludq ZH2, ZR2, ZB4
vpandq ZMASK, ZT3, ZT3
vpmuludq ZH2, ZS3, ZB0
vporq PADBIT_ZMM, ZT4, ZT4
vpmuludq ZH2, ZS4, ZB1
vpaddq ZH1, ZT1, ZH1
vpmuludq ZH2, ZR0, ZB2
vpaddq ZH3, ZT3, ZH3
vpaddq ZH4, ZT4, ZH4
vmovdqu (INP), %xmm5
vmovdqu 16(INP), %xmm6
vpmuludq ZH0, ZR3, ZM3
vpmuludq ZH0, ZR4, ZM4
vpmuludq ZH0, ZR0, ZM0
vpmuludq ZH0, ZR1, ZM1
vpaddq ZM3, ZB3, ZB3
vpaddq ZM4, ZB4, ZB4
vpaddq ZM0, ZB0, ZB0
vpaddq ZM1, ZB1, ZB1
vinserti128 $1, 32(INP), YT0, YT0
vinserti128 $1, 48(INP), YT1, YT1
vpmuludq ZH1, ZR2, ZM3
vpmuludq ZH1, ZR3, ZM4
vpmuludq ZH1, ZS4, ZM0
vpmuludq ZH0, ZR2, ZM2
vpaddq ZM3, ZB3, ZB3
vpaddq ZM4, ZB4, ZB4
vpaddq ZM0, ZB0, ZB0
vpaddq ZM2, ZB2, ZB2
vpmuludq ZH3, ZR0, ZM3
vpmuludq ZH3, ZR1, ZM4
vpmuludq ZH1, ZR0, ZM1
vpmuludq ZH1, ZR1, ZM2
vpaddq ZM3, ZB3, ZB3
vpaddq ZM4, ZB4, ZB4
vpaddq ZM1, ZB1, ZB1
vpaddq ZM2, ZB2, ZB2
vpmuludq ZH4, ZS4, ZM3
vpmuludq ZH4, ZR0, ZM4
vpmuludq ZH3, ZS2, ZM0
vpmuludq ZH3, ZS3, ZM1
vpmuludq ZH3, ZS4, ZM2
vpaddq ZM3, ZB3, ZH3
vpaddq ZM4, ZB4, ZB4
vpaddq ZM0, ZB0, ZB0
vpaddq ZM1, ZB1, ZB1
vpaddq ZM2, ZB2, ZB2
vpmuludq ZH4, ZS1, ZM0
vpmuludq ZH4, ZS2, ZM1
vpmuludq ZH4, ZS3, ZM2
vpaddq ZM0, ZB0, ZH0
vpaddq ZM1, ZB1, ZH1
vpaddq ZM2, ZB2, ZH2
// Summary of calculation results of different blocks
movl $1, %eax
kmovw %eax, %k3
vpermq $0xb1, ZH0, ZB0
vpermq $0xb1, ZH1, ZB1
vpermq $0xb1, ZH2, ZB2
vpermq $0xb1, ZH3, ZB3
vpermq $0xb1, ZB4, ZH4
vpaddq ZB0, ZH0, ZH0
vpaddq ZB1, ZH1, ZH1
vpaddq ZB2, ZH2, ZH2
vpaddq ZB3, ZH3, ZH3
vpaddq ZB4, ZH4, ZH4
vpermq $0x2, ZH0, ZB0
vpermq $0x2, ZH1, ZB1
vpermq $0x2, ZH2, ZB2
vpermq $0x2, ZH3, ZB3
vpermq $0x2, ZH4, ZB4
vpaddq ZB0, ZH0, ZH0
vpaddq ZB1, ZH1, ZH1
vpaddq ZB2, ZH2, ZH2
vpaddq ZB3, ZH3, ZH3
vpaddq ZB4, ZH4, ZH4
vextracti64x4 $0x1, ZH0, YB0
vextracti64x4 $0x1, ZH1, YB1
vextracti64x4 $0x1, ZH2, YB2
vextracti64x4 $0x1, ZH3, YB3
vextracti64x4 $0x1, ZH4, YB4
vpaddq ZB0, ZH0, ZH0{%k3}{z}
vpaddq ZB1, ZH1, ZH1{%k3}{z}
vpaddq ZB2, ZH2, ZH2{%k3}{z}
vpaddq ZB3, ZH3, ZH3{%k3}{z}
vpaddq ZB4, ZH4, ZH4{%k3}{z}
// reduction
vpsrlq $26, YH3, YB3
vpandq YMASK, YH3, YH3
vpaddq YB3, YH4, YH4
vpsrldq $6, YT0, YT2
vpsrldq $6, YT1, YT3
vpsrlq $26, YH0, YB0
vpandq YMASK, YH0, YH0
vpaddq YB0, YH1, YH1
vpunpckhqdq YT1, YT0, YT4
vpunpcklqdq YT1, YT0, YT0
vpunpcklqdq YT3, YT2, YT2
vpsrlq $26, YH4, YB4
vpandq YMASK, YH4, YH4
vpsrlq $26, YH1, YB1
vpandq YMASK, YH1, YH1
vpaddq YB1, YH2, YH2
vpsrlq $30, YT2, YT3
vpsrlq $4, YT2, YT2
vpaddq YB4, YH0, YH0
vpsllq $2, YB4, YB4
vpaddq YB4, YH0, YH0
vpsrlq $26, YT0, YT1
vpsrlq $40, YT4, YT4
vpsrlq $26, YH2, YB2
vpandq YMASK, YH2, YH2
vpaddq YB2, YH3, YH3
vpand YMASK, YT2, YT2
vpand YMASK, YT3, YT3
vpsrlq $26, YH0, YB0
vpandq YMASK, YH0, YH0
vpaddq YB0, YH1, YH1
vpaddq YH2, YT2, YH2
vpand YMASK, YT1, YT1
vpsrlq $26, YH3, YB3
vpand YMASK, YH3, YH3
vpaddq YB3, YH4, YH4
vpand YMASK, YT0, YT0
vpor g_129(%rip), YT4, YT4
addq $64, LEN
jnz .Lblock_4_tail
vpsubq YT2, YH2, YH2
jmp .Lblock_avx512_end
.align 32
.Lblock_4_tail:
BLOCK4_AVX2_TAIL YT0, YT1, YT2, YT3, YT4, YH0, YH1, YH2, YH3, YH4, YB0, YB1, YB2, YB3, YB4, YMASK, %rsp
.Lblock_avx512_end:
vmovd %xmm0, -56(CTX)
vmovd %xmm1, -52(CTX)
vmovd %xmm2, -48(CTX)
vmovd %xmm3, -44(CTX)
vmovd %xmm4, -40(CTX)
vzeroall
lea 8(%r11),%rsp
pop %r15
pop %r14
pop %r13
pop %r12
pop %rbp
pop %rbx
movq LEN, %rax
ret
.cfi_endproc
.size Poly1305BlockAVX512, .-Poly1305BlockAVX512
/**
* Function description: This function is used to clear residual sensitive information in a register.
* Function prototype: void Poly1305CleanRegister();
* Input register: None
* Modify the register:
* Output register: None
* Function/Macro Call: None
*/
.globl Poly1305CleanRegister
.type Poly1305CleanRegister,@function
Poly1305CleanRegister:
.cfi_startproc
vzeroall
vpxorq ZR0, ZR0, ZR0
vpxorq ZR1, ZR1, ZR1
vpxorq ZR2, ZR2, ZR2
vpxorq ZR3, ZR3, ZR3
vpxorq ZR4, ZR4, ZR4
vpxorq ZS1, ZS1, ZS1
vpxorq ZS2, ZS2, ZS2
vpxorq ZS3, ZS3, ZS3
vpxorq ZS4, ZS4, ZS4
vpxorq ZM0, ZM0, ZM0
vpxorq ZM1, ZM1, ZM1
vpxorq ZM2, ZM2, ZM2
vpxorq ZM3, ZM3, ZM3
vpxorq ZM4, ZM4, ZM4
ret
.cfi_endproc
.size Poly1305CleanRegister, .-Poly1305CleanRegister
#endif
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm/poly1305_x86_64_avx512.S | Unix Assembly | unknown | 19,352 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
.file "poly1305_x86_64_macro.s"
.text
.align 32
g_129:
.long 1<<24, 0, 1<<24, 0, 1<<24, 0, 1<<24, 0
.size g_129, .-g_129
.align 32
g_mask26:
.long 0x3ffffff, 0, 0x3ffffff, 0, 0x3ffffff, 0, 0x3ffffff, 0
.size g_mask26, .-g_mask26
.align 32
g_permd_avx2:
.long 2, 2, 2, 3, 2, 0, 2, 1
.size g_permd_avx2, .-g_permd_avx2
.set CTX, %rdi
.set INP, %rsi
.set LEN, %rdx
.set PADBIT, %rcx
.set ACC1, %r14
.set ACC2, %rbx
.set ACC3, %rbp
.set D1, %r8
.set D2, %r9
.set D3, %r10
.set R0, %r11
.set R1, %r12
.set R2, %r13
.set YH0, %ymm0
.set YH1, %ymm1
.set YH2, %ymm2
.set YH3, %ymm3
.set YH4, %ymm4
.set YT0, %ymm5
.set YT1, %ymm6
.set YT2, %ymm7
.set YT3, %ymm8
.set YT4, %ymm9
.set YMASK, %ymm10
.set YB0, %ymm11
.set YB1, %ymm12
.set YB2, %ymm13
.set YB3, %ymm14
.set YB4, %ymm15
/**
* Macro description: x86_64 poly1305 big number multiplication modulo basic instruction implementation (acc1|acc2|acc3) = (acc1|acc2|acc3) * (r0|r1) mod P
* Input register:
* acc1-3: accumulator
* r0-1: key r
* r2: r1 + (r1 >> 2)
* Change register: r8-r14, rbx, rbp, rax
* Output register:
* acc1-3: result of the one block operation
*/
.macro POLY1305_MOD_MUL acc1 acc2 acc3 r0 r1 r2
mulq \acc1 // acc1 * r1
movq %rax, D2
movq \r0, %rax
movq %rdx, D3
mulq \acc1 // acc1 * r0
movq %rax, \acc1
movq \r0, %rax
movq %rdx, D1
mulq \acc2 // acc2 * r0
addq %rax, D2
movq \r2, %rax
adcq %rdx, D3
mulq \acc2 // acc2 * (r1 + (r1 >> 2))
movq \acc3, \acc2
addq %rax, \acc1
adcq %rdx, D1
imulq \r2, \acc2 // acc3 * (r1 + (r1 >> 2))
addq \acc2, D2
movq D1, \acc2
adcq $0, D3
imulq \r0, \acc3 // acc3 * r0
mov $-4, %rax
addq D2, \acc2
adcq \acc3, D3
andq D3, %rax // reduction
movq D3, \acc3
shrq $2, D3
andq $3, \acc3
addq D3, %rax
addq %rax, \acc1
adcq $0, \acc2
adcq $0, \acc3
.endm
/**
* Macro description: converts 130-bit base2^26 data into base 2^64 data.
* Input register:
* a1: large data block 0 in the original format
* d1: large data block 1 in the original format
* a2: large data block 2 in the original format
* d2: large data block 3 in the original format
* r2: big number of data blocks 2 and 3 in the original format
* a3: large data block 4 in the original format
* Modify the register r8, r9, r13, r14, rbx, rbp.
* Output register:
* a1: bits 0 to 63 of the converted big number
* a2: 64-127 bits of the converted big number
* a3: 128-130 bits of the converted big number
* Function/Macro Call: None
*/
.macro CONVERT_26TO64 a1 d1 a2 d2 r2 a3
shrq $6, \d1
shlq $52, \r2
shrq $12, \a2
addq \d1, \a1
shrq $18, \d2
addq \r2, \a1 // 1st 64bit
adcq \d2, \a2
movq \a3, \d1
shlq $40, \d1
shrq $24, \a3
addq \d1, \a2 // 2nd 64bit
adcq $0, \a3 // 3rd 64bit
.endm
/**
* Macro description: converts 130-bit base2^64 data to base 2^26 data.
* Input register:
* a1: large data block 0 in the original format
* a2: large data block 1 in the original format
* a3: large data block 2 in the original format
* Modify the register: r8, r9, r14, rax, rdx, rbp, rbx.
* Output register:
* a4: 0 to 25 digits of the converted big number
* a5: 26 to 51 digits of the converted big number
* a1: 52 to 77 digits of the converted big number
* a2: 78 to 103 bits of the converted big number
* a3: 104-130 bits of the converted big number
* Function/Macro Call: None
*/
.macro CONVERT_64TO26 a1 a2 a3 a4 a5
movq \a1, \a4
movq \a1, \a5
andq $0x3ffffff, \a4 // 1st 26bit
shrq $26, \a5
movd \a4, %xmm0
andq $0x3ffffff, \a5 // 2nd 26bit
shrq $52, \a1
movd \a5, %xmm1
movq \a2, D1
movq \a2, D2
shlq $12, D1
orq D1, \a1
andq $0x3ffffff, \a1 // 3rd 26bit
shrq $14, \a2
movd \a1, %xmm2
shlq $24, \a3
andq $0x3ffffff, \a2 // 4th 26bit
shrq $40, D2
movd \a2, %xmm3
orq D2, \a3 // 5th 26bit
movl $1, 220(CTX)
movd \a3, %xmm4
.endm
/**
* Macro description: preprocessing of converting base2^26 data to base 2^64
* Input register: 128 bits of acc1 and acc2 data
* Change register: r8-r10, r14, and rbx.
* Output register: acc1, acc2, d1, d2, d3
*/
.macro CONVERT_26TO64_PRE acc1 acc2 d1 d2 d3
movq $0xffffffff, \d3 // base2_26 --> base2_64
movq \acc1, \d1
movq \acc2, \d2
andq \d3, \acc1
andq \d3, \acc2
andq $-1*(1<<31), \d1
movq \d2, \d3
andq $-1*(1<<31), \d2
.endm
/**
* Macro description: load accumulator data and key r
* Input register: in_ctx context
* Modify the register: r8, r11-r14, rax, rbp, rbx.
* Output register:
* r0 - r2: key r
* acc1 - acc3: accumulator data
* flag: indicates the data organization flag of the current accumulator.
* mul: r1
*/
.macro LOAD_ACC_R inctx r0 r1 r2 acc1 acc2 acc3 flag mul
movq 24(\inctx), \r0 // load r
movq 32(\inctx), \r1
movl 220(\inctx), \flag // judge the ACC organization form.
movq \r1, \r2
movq (\inctx), \acc1 // load acc
shrq $2, \r2
movq 8(\inctx), \acc2
addq \r1, \r2 // R2 = R1 + (R1 >> 2)
movq 16(\inctx), \acc3
movq \r1, \mul
.endm
/**
* Macro description: The avx2 instruction set implements parallel operation of the last four blocks.
* Input register:
* yh0 - yh4: stores messages.
* yt0 - yt4: stores keys.
* yb0 - yb4: temporary storage of intermediate results
* addr: stack address
* Output register:
* yh0 - yh4: store operation results.
*/
.macro BLOCK4_AVX2_TAIL yt0 yt1 yt2 yt3 yt4 yh0 yh1 yh2 yh3 yh4 yb0 yb1 yb2 yb3 yb4 ymask addr
vpaddq \yt0, \yh0, \yh0
vpaddq \yt1, \yh1, \yh1
vpaddq \yt3, \yh3, \yh3
vpaddq \yt4, \yh4, \yh4
vmovdqu 0x4(\addr), \yt0 // r0^i
vmovdqu 0x24(\addr), \yt1 // r1^i
vmovdqu 0x64(\addr), \yt2 // r2^i
vmovdqu 0xc4(\addr), \yt3 // s3^i
vmovdqu 0x104(\addr), \ymask // s4^i
vpmuludq \yh2, \yt0, \yb2 // b2 = h2 * r0^i
vpmuludq \yh2, \yt1, \yb3 // b3 = h2 * r1^i
vpmuludq \yh2, \yt2, \yb4 // b4 = h2 * r2^i
vpmuludq \yh2, \yt3, \yb0 // b0 = h2 * s3^i
vpmuludq \yh2, \ymask, \yb1 // b1 = h2 * s4^i
vpmuludq \yh1, \yt1, \yt4 // h1 * r1^i
vpmuludq \yh0, \yt1, \yh2 // h0 * r1^i
vpaddq \yt4, \yb2, \yb2 // b2 += h1 * r1^i
vpaddq \yh2, \yb1, \yb1 // b1 += h0 * r1^i
vpmuludq \yh3, \yt1, \yt4 // h3 * r1^i
vpmuludq 0x44(\addr), \yh4, \yh2 // h4 * s1^i
vpaddq \yt4, \yb4, \yb4 // b4 += h3 * r1^i
vpaddq \yh2, \yb0, \yb0 // b0 += h4 * s1^i
vmovdqu 0x84(\addr), \yt1 // load s2^i
vpmuludq \yh4, \yt0, \yt4 // h4 * r0^i
vpmuludq \yh3, \yt0, \yh2 // h3 * r0^i
vpaddq \yt4, \yb4, \yb4 // b4 += h4 * r0^i
vpaddq \yh2, \yb3, \yb3 // b3 += h3 * r0^i
vpmuludq \yh0, \yt0, \yt4 // h0 * r0^i
vpmuludq \yh1, \yt0, \yh2 // h1 * r0^i
vpaddq \yt4, \yb0, \yb0 // b0 += h0 * r0^i
vpaddq \yh2, \yb1, \yb1 // b1 += h1 * r0^i
vpmuludq \yh1, \yt2, \yt4 // h1 * r2^i
vpmuludq \yh0, \yt2, \yh2 // h0 * r2^i
vpaddq \yt4, \yb3, \yb3 // b3 += h1 * r2^i
vpaddq \yh2, \yb2, \yb2 // b2 += h0 * r2^i
vpmuludq \yh4, \yt1, \yt4 // h4 * s2^i
vpmuludq \yh3, \yt1, \yh2 // h3 * s2^i
vpaddq \yt4, \yb1, \yb1 // b1 += h4 * s2^i
vpaddq \yh2, \yb0, \yb0 // b0 += h3 * s2^i
vmovdqu 0xa4(\addr), \yh2 // load r3^i
vpmuludq \yh1, \yh2, \yt4 // h1 * r3^i
vpmuludq \yh0, \yh2, \yh2 // h0 * r3^i
vpaddq \yt4, \yb4, \yb4 // b4 += h1 * r3^i
vpaddq \yh2, \yb3, \yb3 // b3 += h0 * r3^i
vpmuludq \yh4, \yt3, \yt4 // h4 * s3^i
vpmuludq \yh3, \yt3, \yh2 // h3 * s3^i
vpaddq \yt4, \yb2, \yb2 // b2 += h4 * s3^i
vpaddq \yh2, \yb1, \yb1 // b1 += h3 * s3^i (finish)
vpmuludq \yh3, \ymask, \yh3 // h3 * s4^i
vpmuludq \yh4, \ymask, \yh4 // h4 * s4^i
vpaddq \yb2, \yh3, \yh2 // h2 += h3 * s4^i (finish)
vpaddq \yb3, \yh4, \yh3 // h3 += h4 * s4^i (finish)
vpmuludq 0xe4(\addr), \yh0, \yh4 // h0 * r4^i
vpmuludq \yh1, \ymask, \yh0 // h1 * s4^i
vmovdqu g_mask26(%rip), \ymask
vpaddq \yh4, \yb4, \yh4 // h4 += h0 * r4^i (finish)
vpaddq \yh0, \yb0, \yh0 // h0 += h1 * s4^i (finish)
// Summary of calculation results of different blocks
vpsrldq $8, \yh0, \yt0
vpsrldq $8, \yb1, \yt1
vpaddq \yt0, \yh0, \yh0
vpsrldq $8, \yh2, \yt2
vpaddq \yt1, \yb1, \yb1
vpsrldq $8, \yh3, \yt3
vpaddq \yt2, \yh2, \yh2
vpsrldq $8, \yh4, \yt4
vpaddq \yt3, \yh3, \yh3
vpaddq \yt4, \yh4, \yh4
vpermq $0x2, \yh0, \yt0
vpermq $0x2, \yb1, \yt1
vpaddq \yt0, \yh0, \yh0
vpermq $0x2, \yh2, \yt2
vpaddq \yt1, \yb1, \yb1
vpermq $0x2, \yh3, \yt3
vpaddq \yt2, \yh2, \yh2
vpermq $0x2, \yh4, \yt4
vpaddq \yt3, \yh3, \yh3
vpaddq \yt4, \yh4, \yh4
// reduction
vpsrlq $26, \yh3, \yb3
vpand \ymask, \yh3, \yh3
vpaddq \yb3, \yh4, \yh4 // h3 -> h4
vpsrlq $26, \yh0, \yb0
vpand \ymask, \yh0, \yh0
vpaddq \yb0, \yb1, \yh1 // h0 -> h1
vpsrlq $26, \yh4, \yb4
vpand \ymask, \yh4, \yh4
vpsrlq $26, \yh1, \yb1
vpand \ymask, \yh1, \yh1
vpaddq \yb1, \yh2, \yh2 // h1 -> h2
vpaddq \yb4, \yh0, \yh0
vpsllq $2, \yb4, \yb4
vpaddq \yb4, \yh0, \yh0 // h4 -> h0
vpsrlq $26, \yh2, \yb2
vpand \ymask, \yh2, \yh2
vpaddq \yb2, \yh3, \yh3 // h2 -> h3
vpsrlq $26, \yh0, \yb0
vpand \ymask, \yh0, \yh0
vpaddq \yb0, \yh1, \yh1 // h0 -> h1
vpsrlq $26, \yh3, \yb3
vpand \ymask, \yh3, \yh3
vpaddq \yb3, \yh4, \yh4 // h3 -> h4
.endm
#endif
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm/poly1305_x86_64_macro.s | Unix Assembly | unknown | 12,863 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_CBC)
#include "bsl_err_internal.h"
#include "crypt_aes.h"
#include "modes_local.h"
#include "crypt_errno.h"
#include "crypt_modes_cbc.h"
int32_t AES_CBC_EncryptBlock(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx->ciphCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if ((len & 0x0f) != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
(void)CRYPT_AES_CBC_Encrypt(ctx->ciphCtx, in, out, len, ctx->iv);
return CRYPT_SUCCESS;
}
int32_t AES_CBC_DecryptBlock(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx->ciphCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if ((len & 0x0f) != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
(void)CRYPT_AES_CBC_Decrypt(ctx->ciphCtx, in, out, len, ctx->iv);
return CRYPT_SUCCESS;
}
int32_t AES_CBC_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherUpdate(modeCtx, modeCtx->enc ? AES_CBC_EncryptBlock : AES_CBC_DecryptBlock,
in, inLen, out, outLen);
}
int32_t AES_CBC_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherFinal(modeCtx, modeCtx->enc ? AES_CBC_EncryptBlock : AES_CBC_DecryptBlock, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_aes_cbc.c | C | unknown | 2,185 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_CCM)
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "asm_aes_ccm.h"
#include "ccm_core.h"
#include "crypt_modes_ccm.h"
#include "modes_local.h"
static int32_t AesCcmBlocks(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
{
if (ctx->ciphCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
XorCryptData data;
data.in = in;
data.out = out;
data.ctr = ctx->last;
data.tag = ctx->tag;
uint8_t countLen = (ctx->nonce[0] & 0x07) + 1;
uint32_t dataLen = len;
void (*xor)(XorCryptData *data, uint32_t len) = enc ? XorInEncrypt : XorInDecrypt;
void (*crypt_asm)(void *key, uint8_t *nonce, const uint8_t *in, uint8_t *out, uint32_t len) =
enc ? AesCcmEncryptAsm : AesCcmDecryptAsm;
crypt_asm(ctx->ciphCtx, ctx->nonce, data.in, data.out, dataLen);
uint32_t tmpOffset = dataLen & 0xfffffff0;
dataLen &= 0x0fU;
data.in += tmpOffset;
data.out += tmpOffset;
if (dataLen > 0) { // data processing with less than 16 bytes
(void)ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->nonce, ctx->last, CCM_BLOCKSIZE);
xor(&data, dataLen);
MODE_IncCounter(ctx->nonce + CCM_BLOCKSIZE - countLen, countLen); // counter +1
}
return CRYPT_SUCCESS;
}
int32_t MODES_AES_CCM_Encrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
return CcmCrypt(ctx, in, out, len, true, AesCcmBlocks);
}
int32_t MODES_AES_CCM_Decrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
return CcmCrypt(ctx, in, out, len, false, AesCcmBlocks);
}
int32_t AES_CCM_Update(MODES_CCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? MODES_AES_CCM_Encrypt : MODES_AES_CCM_Decrypt, &modeCtx->ccmCtx,
in, inLen, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_aes_ccm.c | C | unknown | 2,558 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef ASM_AES_CCM_H
#define ASM_AES_CCM_H
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_CCM)
#include "crypt_utils.h"
#include "modes_local.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
void AesCcmEncryptAsm(void *key, uint8_t *nonce, const uint8_t *in, uint8_t *out, uint32_t len);
void AesCcmDecryptAsm(void *key, uint8_t *nonce, const uint8_t *in, uint8_t *out, uint32_t len);
void XorInDecrypt(XorCryptData *data, uint32_t len);
void XorInEncrypt(XorCryptData *data, uint32_t len);
void XorInEncryptBlock(XorCryptData *data);
void XorInDecryptBlock(XorCryptData *data);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif
#endif
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_aes_ccm.h | C | unknown | 1,228 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_CFB)
#include "bsl_err_internal.h"
#include "crypt_aes.h"
#include "crypt_errno.h"
#include "crypt_modes_cfb.h"
#include "modes_local.h"
/* Decrypt the 128-bit CFB. Here, len indicates the number of bytes to be processed. */
static int32_t CRYPT_AES_CFB16_Decrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx->modeCtx.ciphCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
const uint8_t *input = in;
uint8_t *output = out;
uint8_t *tmp = ctx->modeCtx.buf;
uint32_t blockSize = ctx->modeCtx.blockSize;
uint32_t left = len;
uint32_t i, k;
// If the remaining encryption iv is not used up last time, use the part to perform exclusive OR.
while (left > 0 && ctx->modeCtx.offset > 0) {
uint8_t tmpInput = *input; // To support the same address in and out
*(output++) = ctx->modeCtx.iv[ctx->modeCtx.offset] ^ *(input++);
// Write the iv to ciphertext to prepare for the next round of encryption.
ctx->modeCtx.iv[ctx->modeCtx.offset] = tmpInput;
ctx->modeCtx.offset = (ctx->modeCtx.offset + 1) % blockSize;
left--;
}
if (left >= blockSize) {
uint32_t processedLen = left - (left % blockSize);
(void)CRYPT_AES_CFB_Decrypt(ctx->modeCtx.ciphCtx, input, output, processedLen, ctx->modeCtx.iv);
UPDATE_VALUES(left, input, output, processedLen);
}
if (left > 0) {
// encrypt the IV
int32_t ret = ctx->modeCtx.ciphMeth->encryptBlock(ctx->modeCtx.ciphCtx, ctx->modeCtx.iv, tmp, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
for (i = 0, k = 0; k < left; k++, i++) {
// Write the iv to ciphertext to prepare for the next round of encryption.
ctx->modeCtx.iv[i] = input[k];
output[k] = input[k] ^ tmp[k];
}
while (i < blockSize) {
ctx->modeCtx.iv[i++] = tmp[k++];
}
ctx->modeCtx.offset = (uint8_t)left;
}
return CRYPT_SUCCESS;
}
int32_t MODE_AES_CFB_Decrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ctx->feedbackBits == 128) { // feedbackBits 128 has assembly optimization
return CRYPT_AES_CFB16_Decrypt(ctx, in, out, len);
} else { // no optimization
return MODES_CFB_Decrypt(ctx, in, out, len);
}
}
int32_t AES_CFB_Update(MODES_CFB_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? MODES_CFB_Encrypt : MODE_AES_CFB_Decrypt, &modeCtx->cfbCtx,
in, inLen, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_aes_cfb.c | C | unknown | 3,485 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_CTR)
#include "bsl_err_internal.h"
#include "crypt_aes.h"
#include "crypt_errno.h"
#include "crypt_utils.h"
#include "crypt_modes_ctr.h"
#include "modes_local.h"
int32_t AES_CTR_EncryptBlock(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
// The ctx, in, and out pointers have been determined at the EAL layer and are not determined again.
if (ctx->ciphCtx == NULL || len == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
uint32_t left = len;
const uint8_t *tmpIn = in;
uint8_t *tmpOut = out;
while ((ctx->offset != 0) && (left > 0)) {
*(tmpOut++) = ((*(tmpIn++)) ^ (ctx->buf[ctx->offset++]));
--left;
ctx->offset &= (uint8_t)(ctx->blockSize - 1);
}
uint32_t blockSize = ctx->blockSize; // ctr supports only 16-byte block size
uint32_t blocks, beCtr32;
while (left >= blockSize) {
blocks = left >> 4; // Shift rightwards by 4 bytes to obtain the number of blocks.
beCtr32 = GET_UINT32_BE(ctx->iv, 12); // offset of 12 bytes, it is used to obtain the lower 32 bits of IV
beCtr32 += blocks;
if (beCtr32 < blocks) {
blocks -= beCtr32;
beCtr32 = 0;
}
// Shift leftwards by 4 bytes to obtain the length of the data involved in the calculation.
uint32_t calLen = blocks << 4;
(void)CRYPT_AES_CTR_Encrypt(ctx->ciphCtx, tmpIn, tmpOut, calLen, ctx->iv);
left -= calLen;
tmpIn += calLen;
tmpOut += calLen;
if (beCtr32 == 0) {
// 16 - 4, the lower 32 bits are carried, and the upper 12 bytes are increased by 1.
MODE_IncCounter(ctx->iv, blockSize - 4);
}
}
if (left > 0) {
(void)ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->iv, ctx->buf, blockSize);
MODE_IncCounter(ctx->iv, ctx->blockSize);
ctx->offset = 0;
while ((left) > 0) {
tmpOut[ctx->offset] = (tmpIn[ctx->offset]) ^ (ctx->buf[ctx->offset]);
--left;
++ctx->offset;
}
}
return CRYPT_SUCCESS;
}
int32_t AES_CTR_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(AES_CTR_EncryptBlock, &modeCtx->commonCtx, in, inLen, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_aes_ctr.c | C | unknown | 3,061 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_ECB)
#include "bsl_err_internal.h"
#include "crypt_aes.h"
#include "crypt_errno.h"
#include "crypt_modes_ecb.h"
#include "modes_local.h"
int32_t AES_ECB_EncryptBlock(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx->ciphCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if ((len & 0x0f) != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
(void)CRYPT_AES_ECB_Encrypt(ctx->ciphCtx, in, out, len);
return CRYPT_SUCCESS;
}
int32_t AES_ECB_DecryptBlock(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx->ciphCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if ((len & 0x0f) != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
(void)CRYPT_AES_ECB_Decrypt(ctx->ciphCtx, in, out, len);
return CRYPT_SUCCESS;
}
int32_t AES_ECB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherUpdate(modeCtx, modeCtx->enc ? AES_ECB_EncryptBlock : AES_ECB_DecryptBlock,
in, inLen, out, outLen);
}
int32_t AES_ECB_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherFinal(modeCtx, modeCtx->enc ? AES_ECB_EncryptBlock : AES_ECB_DecryptBlock, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_aes_ecb.c | C | unknown | 2,167 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_GCM)
#include "crypt_aes.h"
#include "asm_aes_gcm.h"
#include "modes_local.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "crypt_modes_gcm.h"
int32_t AES_GCM_EncryptBlock(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx->ciphCtx == NULL) {
return CRYPT_NULL_INPUT;
}
int32_t ret = CryptLenCheckAndRefresh(ctx, len);
if (ret != CRYPT_SUCCESS) {
return ret;
}
uint32_t lastLen = MODES_GCM_LastHandle(ctx, in, out, len, true);
// Data processing is complete. Exit.
if (lastLen == len) {
return CRYPT_SUCCESS;
}
uint32_t clen = len - lastLen;
if (clen >= 64) { // If the value is greater than 64, the logic for processing large blocks is used.
// invoke the assembly API
uint32_t finishedLen = AES_GCM_EncryptBlockAsm(ctx, in + lastLen, out + lastLen, clen, ctx->ciphCtx);
lastLen += finishedLen; // add the processed length
clen -= finishedLen; // subtract the processed length
}
if (clen >= 16) { // Remaining 16, use small block processing logic
AES_GCM_Encrypt16BlockAsm(ctx, in + lastLen, out + lastLen, clen, ctx->ciphCtx); // call the assembly API
lastLen += clen & 0xfffffff0;
clen = clen & 0x0f; // take the remainder of 16
}
AES_GCM_ClearAsm(); // clear the Neon register
if (clen > 0) { // tail processing
uint32_t ctr = GET_UINT32_BE(ctx->iv, 12);
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->iv, ctx->last, GCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
return ret;
}
uint32_t i;
// encryption
const uint8_t *cin = (const uint8_t *)(in + lastLen);
uint8_t *cout = out + lastLen;
for (i = 0; i < clen; i++) {
cout[i] = cin[i] ^ ctx->last[i];
ctx->remCt[i] = cout[i];
}
ctr++;
PUT_UINT32_BE(ctr, ctx->iv, 12); // offset of 12 bytes, the last four bytes are used
ctx->lastLen = GCM_BLOCKSIZE - clen;
}
return CRYPT_SUCCESS;
}
int32_t AES_GCM_DecryptBlock(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx->ciphCtx == NULL) {
return CRYPT_NULL_INPUT;
}
int32_t ret = CryptLenCheckAndRefresh(ctx, len);
if (ret != CRYPT_SUCCESS) {
return ret;
}
uint32_t lastLen = MODES_GCM_LastHandle(ctx, in, out, len, false);
// Data processing is complete. Exit.
if (lastLen == len) {
return CRYPT_SUCCESS;
}
uint32_t clen = len - lastLen;
if (clen >= 64) { // If the value is greater than 64, the logic for processing large blocks is used.
// invoke the assembly API
uint32_t finishedLen = AES_GCM_DecryptBlockAsm(ctx, in + lastLen, out + lastLen, clen, ctx->ciphCtx);
lastLen += finishedLen; // add the processed length
clen -= finishedLen; // subtract the processed length
}
if (clen >= 16) { // Remaining 16, use small block processing logic
AES_GCM_Decrypt16BlockAsm(ctx, in + lastLen, out + lastLen, clen, ctx->ciphCtx); // call the assembly API
lastLen += clen & 0xfffffff0;
clen = clen & 0x0f; // take the remainder of 16
}
AES_GCM_ClearAsm(); // clear the Neon register
if (clen > 0) { // tail processing
uint32_t ctr = GET_UINT32_BE(ctx->iv, 12);
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->iv, ctx->last, GCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
return ret;
}
uint32_t i;
// encryption
const uint8_t *cin = (const uint8_t *)(in + lastLen);
uint8_t *cout = out + lastLen;
for (i = 0; i < clen; i++) {
ctx->remCt[i] = cin[i];
cout[i] = cin[i] ^ ctx->last[i];
}
ctr++;
PUT_UINT32_BE(ctr, ctx->iv, 12); // offset of 12 bytes, the last four bytes are used
ctx->lastLen = GCM_BLOCKSIZE - clen;
}
return CRYPT_SUCCESS;
}
int32_t AES_GCM_Update(MODES_GCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? AES_GCM_EncryptBlock : AES_GCM_DecryptBlock, &modeCtx->gcmCtx,
in, inLen, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_aes_gcm.c | C | unknown | 4,906 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef ASM_AES_GCM_H
#define ASM_AES_GCM_H
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_GCM)
#include "crypt_modes_gcm.h"
#include "modes_local.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
uint32_t AES_GCM_EncryptBlockAsm(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, void *key);
uint32_t AES_GCM_DecryptBlockAsm(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, void *key);
void AES_GCM_Encrypt16BlockAsm(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, void *key);
void AES_GCM_Decrypt16BlockAsm(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, void *key);
void AES_GCM_ClearAsm(void);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif
#endif
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_aes_gcm.h | C | unknown | 1,334 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_XTS)
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "crypt_aes.h"
#include "crypt_modes_xts.h"
#include "modes_local.h"
int32_t MODES_AES_XTS_Encrypt(MODES_CipherXTSCtx *xtsCtx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (xtsCtx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len < xtsCtx->blockSize) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
(void)CRYPT_AES_XTS_Encrypt(xtsCtx->ciphCtx, in, out, len, xtsCtx->tweak);
return CRYPT_SUCCESS;
}
int32_t MODES_AES_XTS_Decrypt(MODES_CipherXTSCtx *xtsCtx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (xtsCtx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len < xtsCtx->blockSize) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_BUFF_LEN_NOT_ENOUGH);
return CRYPT_MODE_BUFF_LEN_NOT_ENOUGH;
}
(void)CRYPT_AES_XTS_Decrypt(xtsCtx->ciphCtx, in, out, len, xtsCtx->tweak);
return CRYPT_SUCCESS;
}
int32_t AES_XTS_Update(MODES_XTS_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? MODES_AES_XTS_Encrypt : MODES_AES_XTS_Decrypt, &modeCtx->xtsCtx,
in, inLen, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_aes_xts.c | C | unknown | 2,099 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_CBC)
#include "bsl_err_internal.h"
#include "crypt_sm4.h"
#include "crypt_errno.h"
#include "crypt_modes_cbc.h"
#include "modes_local.h"
int32_t MODE_SM4_CBC_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return CRYPT_SM4_CBC_Encrypt(ctx->ciphCtx, in, out, len, ctx->iv);
}
int32_t MODE_SM4_CBC_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return CRYPT_SM4_CBC_Decrypt(ctx->ciphCtx, in, out, len, ctx->iv);
}
int32_t SM4_CBC_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherUpdate(modeCtx, modeCtx->enc ? MODE_SM4_CBC_Encrypt : MODE_SM4_CBC_Decrypt,
in, inLen, out, outLen);
}
int32_t SM4_CBC_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherFinal(modeCtx, modeCtx->enc ? MODE_SM4_CBC_Encrypt : MODE_SM4_CBC_Decrypt, out, outLen);
}
int32_t SM4_CBC_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
void *setKey = enc ? MODES_SM4_SetEncryptKey : MODES_SM4_SetDecryptKey;
return MODES_CipherInitCtx(modeCtx, setKey, &modeCtx->commonCtx, key, keyLen, iv, ivLen, enc);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_sm4_cbc.c | C | unknown | 2,168 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_CFB)
#include "bsl_err_internal.h"
#include "crypt_sm4.h"
#include "crypt_errno.h"
#include "crypt_modes_cfb.h"
#include "modes_local.h"
#include "securec.h"
int32_t MODE_SM4_CFB_Encrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ctx->feedbackBits == 128) { // feedbackBits value of 128 has assembly optimizations
return CRYPT_SM4_CFB_Encrypt(ctx->modeCtx.ciphCtx, in, out, len, ctx->modeCtx.iv, &ctx->modeCtx.offset);
} else { // no assembly optimization
return MODES_CFB_Encrypt(ctx, in, out, len);
}
}
int32_t MODE_SM4_CFB_Decrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ctx->feedbackBits == 128) { // feedbackBits value of 128 has assembly optimizations
return CRYPT_SM4_CFB_Decrypt(ctx->modeCtx.ciphCtx, in, out, len, ctx->modeCtx.iv, &ctx->modeCtx.offset);
} else { // no assembly optimization
return MODES_CFB_Decrypt(ctx, in, out, len);
}
}
int32_t SM4_CFB_InitCtx(MODES_CFB_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
int32_t ret;
if (ivLen != modeCtx->cfbCtx.modeCtx.blockSize) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_IVLEN_ERROR);
return CRYPT_MODES_IVLEN_ERROR;
}
ret = CRYPT_SM4_SetEncryptKey(modeCtx->cfbCtx.modeCtx.ciphCtx, key, keyLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
(void)memcpy_s(modeCtx->cfbCtx.modeCtx.iv, MODES_MAX_IV_LENGTH, iv, ivLen);
modeCtx->enc = enc;
return ret;
}
int32_t SM4_CFB_Update(MODES_CFB_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? MODE_SM4_CFB_Encrypt : MODE_SM4_CFB_Decrypt, &modeCtx->cfbCtx,
in, inLen, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_sm4_cfb.c | C | unknown | 2,720 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_CTR)
#include "bsl_err_internal.h"
#include "crypt_sm4.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "crypt_modes_ctr.h"
#include "modes_local.h"
int32_t MODE_SM4_CTR_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
// ctx, in, and out pointers have been determined at the EAL layer and will not be determined again
if (len == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
uint32_t offset = MODES_CTR_LastHandle(ctx, in, out, len);
uint32_t left = len - offset;
const uint8_t *tmpIn = in + offset;
uint8_t *tmpOut = out + offset;
uint32_t blockSize = ctx->blockSize; // ctr supports only 16-byte block size
uint32_t blocks, beCtr32;
while (left >= blockSize) {
blocks = left >> 4; // Shift rightwards by 4 bytes to obtain the number of blocks.
beCtr32 = GET_UINT32_BE(ctx->iv, 12); // offset of 12 bytes to obtain the IV in lower 32 bits
beCtr32 += blocks;
if (beCtr32 < blocks) {
blocks -= beCtr32;
beCtr32 = 0;
}
// Shift leftwards by 4 bytes to obtain the length of the data involved in the calculation.
uint32_t calLen = blocks << 4;
(void)CRYPT_SM4_CTR_Encrypt(ctx->ciphCtx, tmpIn, tmpOut, calLen / ctx->blockSize, ctx->iv);
left -= calLen;
tmpIn += calLen;
tmpOut += calLen;
if (beCtr32 == 0) {
// 16 - 4, The lower 32 bits are carried, and the upper 12 bytes are increased by 1.
MODE_IncCounter(ctx->iv, blockSize - 4);
}
}
MODES_CTR_RemHandle(ctx, tmpIn, tmpOut, left);
return CRYPT_SUCCESS;
}
int32_t SM4_CTR_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_CipherInitCtx(modeCtx, MODES_SM4_SetEncryptKey, &modeCtx->commonCtx, key, keyLen, iv, ivLen, enc);
}
int32_t SM4_CTR_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(MODE_SM4_CTR_Encrypt, &modeCtx->commonCtx, in, inLen, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_sm4_ctr.c | C | unknown | 2,951 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_ECB)
#include "bsl_err_internal.h"
#include "crypt_sm4.h"
#include "crypt_errno.h"
#include "crypt_modes_ecb.h"
#include "modes_local.h"
int32_t MODE_SM4_ECB_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return CRYPT_SM4_ECB_Encrypt(ctx->ciphCtx, in, out, len);
}
int32_t MODE_SM4_ECB_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return CRYPT_SM4_ECB_Decrypt(ctx->ciphCtx, in, out, len);
}
int32_t SM4_ECB_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
(void) iv;
(void) ivLen;
int32_t ret = enc ? MODES_SM4_SetEncryptKey(&modeCtx->commonCtx, key, keyLen) :
MODES_SM4_SetDecryptKey(&modeCtx->commonCtx, key, keyLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
modeCtx->enc = enc;
return ret;
}
int32_t SM4_ECB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherUpdate(modeCtx, modeCtx->enc ? MODE_SM4_ECB_Encrypt : MODE_SM4_ECB_Decrypt,
in, inLen, out, outLen);
}
int32_t SM4_ECB_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherFinal(modeCtx, modeCtx->enc ? MODE_SM4_ECB_Encrypt : MODE_SM4_ECB_Decrypt, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_sm4_ecb.c | C | unknown | 2,290 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_GCM)
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "crypt_sm4.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "modes_local.h"
#include "crypt_modes_gcm.h"
int32_t MODES_SM4_GCM_SetKey(MODES_CipherGCMCtx *ctx, const uint8_t *key, uint32_t len)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
uint8_t gcmKey[GCM_BLOCKSIZE] = { 0 };
int32_t ret = CRYPT_SM4_SetEncryptKey(ctx->ciphCtx, key, len);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, gcmKey, gcmKey, GCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
GcmTableGen4bit(gcmKey, ctx->hTable);
ctx->tagLen = 16; // The default tag length is 128 bits, that is, 16 bytes.
BSL_SAL_CleanseData(gcmKey, sizeof(gcmKey));
return CRYPT_SUCCESS;
}
static void GcmRemHandle(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
{
(void)ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->iv, ctx->last, GCM_BLOCKSIZE);
uint32_t i;
if (enc) {
for (i = 0; i < len; i++) {
out[i] = in[i] ^ ctx->last[i];
ctx->remCt[i] = out[i];
}
} else {
for (i = 0; i < len; i++) {
ctx->remCt[i] = in[i];
out[i] = in[i] ^ ctx->last[i];
}
}
uint32_t ctr = GET_UINT32_BE(ctx->iv, 12); // offset 12 bytes and obtain the last four bytes
ctr++;
PUT_UINT32_BE(ctr, ctx->iv, 12); // offset 12 bytes and obtain the last four bytes
ctx->lastLen = GCM_BLOCKSIZE - len;
}
int32_t MODES_SM4_GCM_EncryptBlock(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
ctx->plaintextLen += len;
uint32_t lastLen = MODES_GCM_LastHandle(ctx, in, out, len, true);
// Data processing is complete. Exit.
if (lastLen == len) {
return CRYPT_SUCCESS;
}
const uint8_t *tmpIn = in + lastLen;
uint8_t *tmpOut = out + lastLen;
uint32_t clen = len - lastLen;
if (clen >= GCM_BLOCKSIZE) {
uint32_t calLen = clen & 0xfffffff0;
(void)CRYPT_SM4_CTR_Encrypt(ctx->ciphCtx, tmpIn, tmpOut, calLen / GCM_BLOCKSIZE, ctx->iv);
GcmHashMultiBlock(ctx->ghash, ctx->hTable, tmpOut, calLen);
clen -= calLen;
tmpIn += calLen;
tmpOut += calLen;
}
if (clen > 0) { // tail processing
GcmRemHandle(ctx, tmpIn, tmpOut, clen, true);
}
return CRYPT_SUCCESS;
}
int32_t MODES_SM4_GCM_DecryptBlock(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
ctx->plaintextLen += len;
uint32_t lastLen = MODES_GCM_LastHandle(ctx, in, out, len, false);
// Data processing is complete. Exit.
if (lastLen == len) {
return CRYPT_SUCCESS;
}
const uint8_t *tmpIn = in + lastLen;
uint8_t *tmpOut = out + lastLen;
uint32_t clen = len - lastLen;
if (clen >= GCM_BLOCKSIZE) {
uint32_t calLen = clen & 0xfffffff0; // Obtains the length that is an integer multiple of 16 bytes.
GcmHashMultiBlock(ctx->ghash, ctx->hTable, tmpIn, calLen);
(void)CRYPT_SM4_CTR_Encrypt(ctx->ciphCtx, tmpIn, tmpOut, calLen / GCM_BLOCKSIZE, ctx->iv);
tmpIn += calLen;
tmpOut += calLen;
clen -= calLen;
}
if (clen > 0) { // tail processing
GcmRemHandle(ctx, tmpIn, tmpOut, clen, false);
}
return CRYPT_SUCCESS;
}
int32_t SM4_GCM_InitCtx(MODES_GCM_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
int32_t ret = MODES_SM4_GCM_SetKey(&modeCtx->gcmCtx, key, keyLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = MODES_GCM_SetIv(&modeCtx->gcmCtx, iv, ivLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
(void)MODES_GCM_DeInitCtx(modeCtx);
return ret;
}
modeCtx->enc = enc;
return ret;
}
int32_t SM4_GCM_Update(MODES_GCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? MODES_SM4_GCM_EncryptBlock : MODES_SM4_GCM_DecryptBlock,
&modeCtx->gcmCtx, in, inLen, out, outLen);
}
#endif
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_sm4_gcm.c | C | unknown | 4,963 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_OFB)
#include "crypt_modes_ofb.h"
int32_t SM4_OFB_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_OFB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
int32_t SM4_OFB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_OFB_Update(modeCtx, in, inLen, out, outLen);
}
#endif
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_sm4_ofb_armv8.c | C | unknown | 1,058 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_OFB)
#include "bsl_err_internal.h"
#include "crypt_sm4.h"
#include "crypt_errno.h"
#include "crypt_modes_ofb.h"
#include "modes_local.h"
int32_t MODE_SM4_OFB_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return CRYPT_SM4_OFB_Encrypt(ctx->ciphCtx, in, out, len, ctx->iv, &ctx->offset);
}
int32_t MODE_SM4_OFB_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return CRYPT_SM4_OFB_Decrypt(ctx->ciphCtx, in, out, len, ctx->iv, &ctx->offset);
}
int32_t SM4_OFB_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
void *setKey = MODES_SM4_SetEncryptKey;
return MODES_CipherInitCtx(modeCtx, setKey, &modeCtx->commonCtx, key, keyLen, iv, ivLen, enc);
}
int32_t SM4_OFB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? MODE_SM4_OFB_Encrypt : MODE_SM4_OFB_Decrypt, &modeCtx->commonCtx,
in, inLen, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_sm4_ofb_x86_64.c | C | unknown | 1,985 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_SM4
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "crypt_sm4.h"
#include "modes_local.h"
int32_t MODES_SM4_SetEncryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len)
{
return CRYPT_SM4_SetEncryptKey(ctx->ciphCtx, key, len);
}
int32_t MODES_SM4_SetDecryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len)
{
return CRYPT_SM4_SetDecryptKey(ctx->ciphCtx, key, len);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_sm4_setkey.c | C | unknown | 1,046 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_XTS)
#include "bsl_err_internal.h"
#include "crypt_sm4.h"
#include "crypt_errno.h"
#include "modes_local.h"
#include "crypt_modes_xts.h"
int32_t MODES_SM4_XTS_Encrypt(MODES_CipherXTSCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
return CRYPT_SM4_XTS_Encrypt(ctx->ciphCtx, in, out, len, ctx->tweak);
}
int32_t MODES_SM4_XTS_Decrypt(MODES_CipherXTSCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return CRYPT_SM4_XTS_Decrypt(ctx->ciphCtx, in, out, len, ctx->tweak);
}
int32_t SM4_XTS_Update(MODES_XTS_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? MODES_SM4_XTS_Encrypt : MODES_SM4_XTS_Decrypt, &modeCtx->xtsCtx,
in, inLen, out, outLen);
}
int32_t SM4_XTS_InitCtx(MODES_XTS_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
int32_t ret;
if (key == NULL || iv == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (enc) {
ret = CRYPT_SM4_XTS_SetEncryptKey(modeCtx->xtsCtx.ciphCtx, key, keyLen);
} else {
ret = CRYPT_SM4_XTS_SetDecryptKey(modeCtx->xtsCtx.ciphCtx, key, keyLen);
}
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = MODES_XTS_SetIv(&modeCtx->xtsCtx, iv, ivLen);
if (ret != CRYPT_SUCCESS) {
(void)MODES_XTS_DeInitCtx(modeCtx);
return ret;
}
modeCtx->enc = enc;
return ret;
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/asm_sm4_xts.c | C | unknown | 2,373 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CCM_CORE_H
#define CCM_CORE_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CCM
#include "crypt_modes_ccm.h"
#include "modes_local.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
typedef int32_t (*CcmCore)(MODES_CipherCCMCtx *, const uint8_t *, uint8_t *, uint32_t, bool);
int32_t CcmCrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc, const CcmCore func);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/ccm_core.h | C | unknown | 1,018 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef GHASH_CORE_H
#define GHASH_CORE_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_GCM
#include "crypt_modes_gcm.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
void GcmTableGen4bitAsm(const MODES_GCM_GF128 *H, MODES_GCM_GF128 hTable[16]);
void GcmMultH4bitAsm(uint8_t t[GCM_BLOCKSIZE], const MODES_GCM_GF128 hTable[16]);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/ghash_core.h | C | unknown | 940 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_MODES
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "modes_local.h"
#ifdef HITLS_CRYPTO_CTR
#include "crypt_modes_ctr.h"
#endif
#ifdef HITLS_CRYPTO_CBC
#include "crypt_modes_cbc.h"
#endif
#ifdef HITLS_CRYPTO_ECB
#include "crypt_modes_ecb.h"
#endif
#ifdef HITLS_CRYPTO_GCM
#include "crypt_modes_gcm.h"
#endif
#ifdef HITLS_CRYPTO_CCM
#include "crypt_modes_ccm.h"
#endif
#ifdef HITLS_CRYPTO_XTS
#include "crypt_modes_xts.h"
#endif
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
#include "crypt_modes_chacha20poly1305.h"
#endif
#ifdef HITLS_CRYPTO_CFB
#include "crypt_modes_cfb.h"
#endif
#ifdef HITLS_CRYPTO_OFB
#include "crypt_modes_ofb.h"
#endif
#ifdef HITLS_CRYPTO_WRAP
#include "crypt_modes_aes_wrap.h"
#endif
int32_t MODE_NewCtxInternal(MODES_CipherCtx *ctx, const EAL_SymMethod *method)
{
ctx->commonCtx.ciphCtx = BSL_SAL_Calloc(1, method->ctxSize);
if (ctx->commonCtx.ciphCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
// block mode blockSize equal symm blockSize
ctx->commonCtx.blockSize = method->blockSize;
ctx->commonCtx.ciphMeth = method;
ctx->commonCtx.offset = 0;
return CRYPT_SUCCESS;
}
MODES_CipherCtx *MODES_CipherNewCtx(int32_t algId)
{
const EAL_SymMethod *method = EAL_GetSymMethod(algId);
if (method == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return NULL;
}
MODES_CipherCtx *ctx = BSL_SAL_Calloc(1, sizeof(MODES_CipherCtx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return ctx;
}
ctx->algId = algId;
int32_t ret = MODE_NewCtxInternal(ctx, method);
if (ret != CRYPT_SUCCESS) {
BSL_SAL_Free(ctx);
return NULL;
}
return ctx;
}
int32_t MODES_CipherInitCommonCtx(MODES_CipherCommonCtx *modeCtx, void *setSymKey, void *keyCtx,
const uint8_t *key, uint32_t keyLen, const uint8_t *iv, uint32_t ivLen)
{
int32_t ret;
if (modeCtx->ciphMeth == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (iv == NULL && ivLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
ret = ((SetKey)setSymKey)(keyCtx, key, keyLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = MODES_SetIv(modeCtx, iv, ivLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
return CRYPT_SUCCESS;
}
int32_t MODES_CipherInitCtx(MODES_CipherCtx *ctx, void *setSymKey, void *keyCtx, const uint8_t *key, uint32_t keyLen,
const uint8_t *iv, uint32_t ivLen, bool enc)
{
ctx->enc = enc;
return MODES_CipherInitCommonCtx(&ctx->commonCtx, setSymKey, keyCtx, key, keyLen, iv, ivLen);
}
int32_t MODE_CheckUpdateParam(uint8_t blockSize, uint32_t cacheLen, uint32_t inLen, uint32_t *outLen)
{
if (inLen + cacheLen < inLen) { // Integer flipping
BSL_ERR_PUSH_ERROR(CRYPT_EAL_BUFF_LEN_TOO_LONG);
return CRYPT_EAL_BUFF_LEN_TOO_LONG;
}
if ((*outLen) < ((inLen + cacheLen) / blockSize * blockSize)) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_BUFF_LEN_NOT_ENOUGH);
return CRYPT_EAL_BUFF_LEN_NOT_ENOUGH;
}
return CRYPT_SUCCESS;
}
static bool IfXts(CRYPT_CIPHER_AlgId id)
{
return id == CRYPT_CIPHER_AES128_XTS || id == CRYPT_CIPHER_AES256_XTS || id == CRYPT_CIPHER_SM4_XTS;
}
static int32_t UnPaddingISO7816(const uint8_t *pad, uint32_t padLen, uint32_t *finLen)
{
const uint8_t *p = pad;
uint32_t len = padLen - 1;
while (*(p + len) == 0 && len > 0) {
len--;
}
len = (*(p + len) == 0x80) ? len : padLen;
if (len == padLen) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_CIPHER_DATA_ERROR);
return CRYPT_EAL_CIPHER_DATA_ERROR;
}
(*finLen) = len;
return CRYPT_SUCCESS;
}
static int32_t UnPaddingX923(const uint8_t *pad, uint32_t padLen, uint32_t *finLen)
{
uint32_t len, pos, i;
uint32_t check = 0;
len = pad[padLen - 1];
check |= (uint32_t)(len > padLen);
pos = padLen - len;
for (i = 0; i < padLen - 1; i++) {
check |= (pad[i] * (uint32_t)(i >= pos));
}
if (check != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_CIPHER_DATA_ERROR);
return CRYPT_EAL_CIPHER_DATA_ERROR;
}
(*finLen) = padLen - len;
return CRYPT_SUCCESS;
}
static int32_t UnPaddingPkcs(const uint8_t *pad, uint32_t padLen, uint32_t *finLen)
{
uint32_t len, pos, i;
uint32_t check = 0;
len = pad[padLen - 1];
check |= (uint32_t)((len == 0) || (len > padLen));
pos = padLen - len;
for (i = 0; i < padLen; i++) {
check |= ((pad[i] ^ len) * (uint32_t)(i >= pos));
}
if (check != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_CIPHER_DATA_ERROR);
return CRYPT_EAL_CIPHER_DATA_ERROR;
}
(*finLen) = padLen - len;
return CRYPT_SUCCESS;
}
int32_t MODES_BlockUnPadding(int32_t padding, const uint8_t *pad, uint32_t padLen, uint32_t *dataLen)
{
int32_t ret = 0;
uint32_t len = *dataLen;
switch (padding) {
case CRYPT_PADDING_ISO7816:
ret = UnPaddingISO7816(pad, padLen, &len);
break;
case CRYPT_PADDING_X923:
ret = UnPaddingX923(pad, padLen, &len);
break;
case CRYPT_PADDING_PKCS5:
case CRYPT_PADDING_PKCS7:
ret = UnPaddingPkcs(pad, padLen, &len);
break;
default:
break;
}
*dataLen = len;
return ret;
}
int32_t MODES_BlockPadding(int32_t algId, int32_t padding, uint8_t blockSize, uint8_t *data, uint8_t *dataLen)
{
uint8_t tempLen = *dataLen;
uint8_t *pad = data + tempLen;
uint8_t padLen = blockSize - tempLen;
uint8_t i;
*dataLen += padLen;
switch (padding) {
case CRYPT_PADDING_NONE:
*dataLen = tempLen;
if (tempLen % blockSize != 0) {
return IfXts(algId) ? CRYPT_SUCCESS : CRYPT_MODE_ERR_INPUT_LEN;
}
break;
case CRYPT_PADDING_ZEROS:
for (i = 0; i < padLen; i++) {
pad[i] = 0x00L;
}
break;
case CRYPT_PADDING_ISO7816:
pad[0] = 0x80;
for (i = 1; i < padLen; i++) {
pad[i] = 0x00L;
}
break;
case CRYPT_PADDING_X923:
for (i = 0; i < padLen - 1; i++) {
pad[i] = 0x00L;
}
pad[padLen - 1] = padLen;
break;
case CRYPT_PADDING_PKCS5:
case CRYPT_PADDING_PKCS7:
for (i = 0; i < padLen; i++) {
pad[i] = padLen;
}
break;
default:
*dataLen = tempLen;
return CRYPT_INVALID_ARG;
}
return CRYPT_SUCCESS;
}
int32_t MODES_CipherUpdateCache(MODES_CipherCtx *ctx, void *blockUpdate, const uint8_t **in, uint32_t *inLen,
uint8_t **out, uint32_t *outLen)
{
int32_t ret;
uint8_t blockSize = ctx->commonCtx.blockSize;
// Process the cache. If there is cached data, the cache data is padded into a block first.
if (ctx->dataLen > 0) {
uint8_t padding = blockSize - ctx->dataLen;
padding = (*inLen) > (padding) ? padding : (uint8_t)(*inLen);
if (padding != 0) {
(void)memcpy_s(ctx->data + ctx->dataLen, (EAL_MAX_BLOCK_LENGTH - ctx->dataLen), (*in), padding);
(*inLen) -= padding;
(*in) += padding;
ctx->dataLen += padding;
}
}
// No block is formed, return.
if (ctx->dataLen != blockSize) {
return CRYPT_SUCCESS;
}
// If the block is padded, perform operations on this block first.
if (ctx->enc) {
ret = ((EncryptBlock)blockUpdate)(&ctx->commonCtx, ctx->data, *out, blockSize);
} else {
// If it's decryption and the cached data + input data is equal to blockSize,
// may be it's the last piece of data with padding, the data is cached in the ctx and left for final processing.
if ((*inLen) == 0 && (ctx->pad != CRYPT_PADDING_NONE)) {
(*outLen) = 0;
return CRYPT_SUCCESS;
}
ret = ((DecryptBlock)blockUpdate)(&ctx->commonCtx, ctx->data, *out, blockSize);
}
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ctx->dataLen = 0;
(*outLen) = blockSize;
(*out) += blockSize;
return CRYPT_SUCCESS;
}
int32_t MODES_CipherFinal(MODES_CipherCtx *modeCtx, void *blockUpdate, uint8_t *out, uint32_t *outLen)
{
int32_t ret;
uint32_t outLenTemp;
if (out == NULL || outLen == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (modeCtx->pad != CRYPT_PADDING_NONE && (*outLen) < modeCtx->commonCtx.blockSize) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_BUFF_LEN_NOT_ENOUGH);
return CRYPT_EAL_BUFF_LEN_NOT_ENOUGH;
}
if (modeCtx->enc) {
ret = MODES_BlockPadding(modeCtx->algId, modeCtx->pad,
modeCtx->commonCtx.blockSize, modeCtx->data, &modeCtx->dataLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
if (modeCtx->dataLen == 0) {
*outLen = modeCtx->dataLen;
return CRYPT_SUCCESS;
}
ret = ((EncryptBlock)blockUpdate)(&modeCtx->commonCtx, modeCtx->data, out, modeCtx->dataLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
*outLen = modeCtx->dataLen;
} else {
if (modeCtx->dataLen == 0) {
*outLen = modeCtx->dataLen;
return CRYPT_SUCCESS;
}
ret = ((DecryptBlock)blockUpdate)(&modeCtx->commonCtx, modeCtx->data, out, modeCtx->dataLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
outLenTemp = modeCtx->dataLen;
ret = MODES_BlockUnPadding(modeCtx->pad, out, modeCtx->commonCtx.blockSize, &outLenTemp);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
*outLen = outLenTemp;
}
modeCtx->dataLen = 0;
return ret;
}
int32_t MODES_CipherUpdate(MODES_CipherCtx *modeCtx, void *blockUpdate, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
int32_t ret;
uint32_t tmpLen = inLen;
const uint8_t *tmpIn = in;
uint8_t *tmpOut = (uint8_t *)out;
ret = MODE_CheckUpdateParam(modeCtx->commonCtx.blockSize, modeCtx->dataLen, inLen, outLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
*outLen = 0;
ret = MODES_CipherUpdateCache(modeCtx, blockUpdate, &tmpIn, &tmpLen, &tmpOut, outLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
if (tmpLen == 0) {
return CRYPT_SUCCESS;
}
uint8_t left = tmpLen % modeCtx->commonCtx.blockSize;
uint32_t len = tmpLen - left;
if (len > 0) {
if (modeCtx->enc) {
ret = ((EncryptBlock)blockUpdate)(&modeCtx->commonCtx, tmpIn, tmpOut, len);
} else {
// If it's decryption and the cached data + input data is equal to blockSize,
// may be it's the last piece of data with padding, the data is cached in the ctx and left for final processing.
if ((modeCtx->pad != CRYPT_PADDING_NONE) && left == 0) {
left = modeCtx->commonCtx.blockSize;
len -= modeCtx->commonCtx.blockSize;
}
if (len > 0) {
ret = ((DecryptBlock)blockUpdate)(&modeCtx->commonCtx, tmpIn, tmpOut, len);
}
}
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
}
// Process the new cache.
if (left > 0) {
(void)memcpy_s(modeCtx->data, modeCtx->commonCtx.blockSize, tmpIn + len, left);
modeCtx->dataLen = left;
}
// The encryption/decryption is successful. OutLen is updated.
(*outLen) += len;
return CRYPT_SUCCESS;
}
void MODES_Clean(MODES_CipherCommonCtx *ctx)
{
if (ctx == NULL) {
return;
}
BSL_SAL_CleanseData((void *)(ctx->buf), MODES_MAX_BUF_LENGTH);
BSL_SAL_CleanseData((void *)(ctx->iv), MODES_MAX_IV_LENGTH);
ctx->ciphMeth->cipherDeInitCtx(ctx->ciphCtx);
ctx->offset = 0;
ctx->ivIndex = 0;
}
int32_t MODES_CipherDeInitCtx(MODES_CipherCtx *modeCtx)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
(void)memset_s(modeCtx->data, EAL_MAX_BLOCK_LENGTH, 0, EAL_MAX_BLOCK_LENGTH);
modeCtx->dataLen = 0;
modeCtx->pad = CRYPT_PADDING_NONE;
MODES_Clean(&modeCtx->commonCtx);
return CRYPT_SUCCESS;
}
void MODES_CipherFreeCtx(MODES_CipherCtx *modeCtx)
{
if (modeCtx == NULL) {
return;
}
(void)MODES_CipherDeInitCtx(modeCtx);
BSL_SAL_FREE(modeCtx->commonCtx.ciphCtx);
BSL_SAL_Free(modeCtx);
}
int32_t MODES_SetIv(MODES_CipherCommonCtx *ctx, const uint8_t *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != ctx->blockSize) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_IVLEN_ERROR);
return CRYPT_MODES_IVLEN_ERROR;
}
if (memcpy_s(ctx->iv, MODES_MAX_IV_LENGTH, val, len) != EOK) {
BSL_ERR_PUSH_ERROR(CRYPT_SECUREC_FAIL);
return CRYPT_SECUREC_FAIL;
}
ctx->offset = 0; // If the IV value is changed, the original offset is useless.
ctx->ivIndex = 0;
return CRYPT_SUCCESS;
}
int32_t MODES_GetIv(MODES_CipherCommonCtx *ctx, uint8_t *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
uint32_t ivLen = ctx->blockSize;
if (len != ivLen) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
(void)memcpy_s(val, len, ctx->iv, ivLen);
return CRYPT_SUCCESS;
}
int32_t MODES_CipherCtrl(MODES_CipherCtx *ctx, int32_t opt, void *val, uint32_t len)
{
switch (opt) {
case CRYPT_CTRL_REINIT_STATUS:
(void)memset_s(ctx->data, EAL_MAX_BLOCK_LENGTH, 0, EAL_MAX_BLOCK_LENGTH);
ctx->dataLen = 0;
ctx->pad = CRYPT_PADDING_NONE;
return MODES_SetIv(&ctx->commonCtx, val, len);
case CRYPT_CTRL_GET_IV:
return MODES_GetIv(&ctx->commonCtx, (uint8_t *)val, len);
default:
if (ctx->commonCtx.ciphMeth == NULL ||
ctx->commonCtx.ciphMeth->cipherCtrl == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TYPE_ERROR);
return CRYPT_MODES_CTRL_TYPE_ERROR;
}
return ctx->commonCtx.ciphMeth->cipherCtrl(ctx->commonCtx.ciphCtx, opt, val, len);
}
}
int32_t MODES_CipherStreamProcess(void *processFuncs, void *ctx, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
int32_t ret;
if (inLen == 0) {
*outLen = 0;
return CRYPT_SUCCESS;
}
if (inLen > *outLen) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_BUFF_LEN_NOT_ENOUGH);
return CRYPT_MODE_BUFF_LEN_NOT_ENOUGH;
}
ret = ((CipherStreamProcess)(processFuncs))(ctx, in, out, inLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
*outLen = inLen;
return CRYPT_SUCCESS;
}
// Note that CRYPT_PADDING_ZEROS cannot restore the plaintext length.
// If uses it, need to maintain the length themselves
int32_t MODES_SetPaddingCheck(int32_t pad)
{
if (pad >= CRYPT_PADDING_MAX_COUNT || pad < CRYPT_PADDING_NONE) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_PADDING_NOT_SUPPORT);
return CRYPT_MODES_PADDING_NOT_SUPPORT;
}
return CRYPT_SUCCESS;
}
int32_t MODES_SetEncryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len)
{
// The ctx and key have been checked at the EAL layer and will not be checked again here.
// The keyMethod will support registration in the future. Therefore, this check is added.
if (ctx == NULL || ctx->ciphMeth == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return ctx->ciphMeth->setEncryptKey(ctx->ciphCtx, key, len);
}
int32_t MODES_SetDecryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len)
{
// The ctx and key have been checked at the EAL layer and will not be checked again here.
// The keyMethod will support registration in the future. Therefore, this check is added.
if (ctx == NULL || ctx->ciphMeth == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return ctx->ciphMeth->setDecryptKey(ctx->ciphCtx, key, len);
}
#endif // HITLS_CRYPTO_MODES
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/modes.c | C | unknown | 17,606 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CBC
#include "securec.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "crypt_modes_cbc.h"
#include "modes_local.h"
#define CBC_UPDATE_VALUES(l, i, o, len) \
do { \
(l) -= (len); \
(i) += (len); \
(o) += (len); \
} while (false)
int32_t MODES_CBC_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
uint32_t blockSize = ctx->blockSize;
int32_t ret;
uint8_t *iv = ctx->iv;
uint8_t *tmp = ctx->buf;
uint32_t left = len;
const uint8_t *input = in;
uint8_t *output = out;
// The ctx, in, and out pointers have been determined at the EAL layer and are not determined again.
if ((left % blockSize) != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
while (left >= blockSize) {
/* Plaintext XOR IV. BlockSize must be an integer multiple of 4 bytes. */
DATA32_XOR(input, iv, tmp, blockSize);
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, tmp, output, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
/* The current encryption result is used as the next IV value. */
iv = output;
/* Offset length is the size of integer multiple blocks */
CBC_UPDATE_VALUES(left, input, output, blockSize);
}
if (memcpy_s(ctx->iv, MODES_MAX_IV_LENGTH, iv, blockSize) != EOK) {
BSL_ERR_PUSH_ERROR(CRYPT_SECUREC_FAIL);
return CRYPT_SECUREC_FAIL;
}
return CRYPT_SUCCESS;
}
int32_t MODES_CBC_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
const uint8_t *iv = ctx->iv;
uint8_t *tmp = ctx->buf;
uint32_t blockSize = ctx->blockSize;
uint32_t left = len;
uint8_t *output = out;
uint8_t tmpChar;
const uint8_t *input = in;
// The ctx, in, and out pointers have been determined at the EAL layer and are not determined again.
if ((left % blockSize) != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
// In the case where the input and output are at the same address,
// the judgment should be placed outside the while loop. Otherwise, the performance will be affected.
if (in != out) {
while (left >= blockSize) {
int32_t ret = ctx->ciphMeth->decryptBlock(ctx->ciphCtx, input, tmp, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
/* The ciphertext is used as the next IV value. BlockSize must be an integer multiple of 4 bytes. */
DATA32_XOR(iv, tmp, output, blockSize);
iv = input;
CBC_UPDATE_VALUES(left, input, output, blockSize);
}
if (iv != ctx->iv) {
(void)memcpy_s(ctx->iv, MODES_MAX_IV_LENGTH, iv, blockSize);
}
} else {
while (left >= blockSize) {
int32_t ret = ctx->ciphMeth->decryptBlock(ctx->ciphCtx, input, tmp, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
for (uint32_t i = 0; i < blockSize; i++) {
tmpChar = input[i];
output[i] = tmp[i] ^ ctx->iv[i];
ctx->iv[i] = tmpChar;
}
CBC_UPDATE_VALUES(left, input, output, blockSize);
}
}
return CRYPT_SUCCESS;
}
MODES_CipherCtx *MODES_CBC_NewCtx(int32_t algId)
{
return MODES_CipherNewCtx(algId);
}
int32_t MODES_CBC_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
void *setKeyFuncs = enc ? modeCtx->commonCtx.ciphMeth->setEncryptKey : modeCtx->commonCtx.ciphMeth->setDecryptKey;
return MODES_CipherInitCtx(modeCtx, setKeyFuncs, modeCtx->commonCtx.ciphCtx, key, keyLen, iv, ivLen, enc);
}
int32_t MODES_CBC_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherUpdate(modeCtx, modeCtx->enc ? MODES_CBC_Encrypt : MODES_CBC_Decrypt,
in, inLen, out, outLen);
}
int32_t MODES_CBC_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherFinal(modeCtx, modeCtx->enc ? MODES_CBC_Encrypt : MODES_CBC_Decrypt, out, outLen);
}
int32_t MODES_CBC_DeInitCtx(MODES_CipherCtx *modeCtx)
{
return MODES_CipherDeInitCtx(modeCtx);
}
int32_t MODES_CBC_Ctrl(MODES_CipherCtx *modeCtx, int32_t cmd, void *val, uint32_t valLen)
{
int32_t ret;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (cmd) {
case CRYPT_CTRL_SET_PADDING:
if (val == NULL || valLen != sizeof(int32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
ret = MODES_SetPaddingCheck(*(int32_t *)val);
if (ret != CRYPT_SUCCESS) {
return ret;
}
modeCtx->pad = *(int32_t *)val;
return CRYPT_SUCCESS;
case CRYPT_CTRL_GET_PADDING:
if (val == NULL || valLen != sizeof(int32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
*(int32_t *)val = modeCtx->pad;
return CRYPT_SUCCESS;
case CRYPT_CTRL_GET_BLOCKSIZE:
if (val == NULL || valLen != sizeof(uint32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
*(int32_t *)val = modeCtx->commonCtx.ciphMeth->blockSize;
return CRYPT_SUCCESS;
default:
return MODES_CipherCtrl(modeCtx, cmd, val, valLen);
}
}
void MODES_CBC_FreeCtx(MODES_CipherCtx *modeCtx)
{
MODES_CipherFreeCtx(modeCtx);
}
int32_t MODES_CBC_UpdateEx(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_AES128_CBC:
case CRYPT_CIPHER_AES192_CBC:
case CRYPT_CIPHER_AES256_CBC:
#ifdef HITLS_CRYPTO_AES
return AES_CBC_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
case CRYPT_CIPHER_SM4_CBC:
#ifdef HITLS_CRYPTO_SM4
return SM4_CBC_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_CBC_Update(modeCtx, in, inLen, out, outLen);
}
}
int32_t MODES_CBC_InitCtxEx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, void *param, bool enc)
{
(void)param;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_SM4_CBC:
#ifdef HITLS_CRYPTO_SM4
return SM4_CBC_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_CBC_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
}
int32_t MODES_CBC_FinalEx(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_AES128_CBC:
case CRYPT_CIPHER_AES192_CBC:
case CRYPT_CIPHER_AES256_CBC:
#ifdef HITLS_CRYPTO_AES
return AES_CBC_Final(modeCtx, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
case CRYPT_CIPHER_SM4_CBC:
#ifdef HITLS_CRYPTO_SM4
return SM4_CBC_Final(modeCtx, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_CBC_Final(modeCtx, out, outLen);
}
}
#endif // HITLS_CRYPTO_CBC
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/modes_cbc.c | C | unknown | 8,810 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CCM
#include <stdint.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "modes_local.h"
#include "ccm_core.h"
#include "crypt_modes_ccm.h"
#include "crypt_modes.h"
void XorInEncrypt(XorCryptData *data, uint32_t len)
{
uint32_t i;
for (i = 0; i < len; i++) {
data->tag[i] ^= data->in[i];
data->out[i] = data->in[i] ^ data->ctr[i];
}
}
void XorInEncryptBlock(XorCryptData *data)
{
DATA64_XOR(data->in, data->tag, data->tag, CCM_BLOCKSIZE);
DATA64_XOR(data->in, data->ctr, data->out, CCM_BLOCKSIZE);
}
void XorInDecrypt(XorCryptData *data, uint32_t len)
{
uint32_t i;
// Decryption
for (i = 0; i < len; i++) {
data->out[i] = data->in[i] ^ data->ctr[i];
data->tag[i] ^= data->out[i];
}
}
void XorInDecryptBlock(XorCryptData *data)
{
DATA64_XOR(data->in, data->ctr, data->out, CCM_BLOCKSIZE);
DATA64_XOR(data->out, data->tag, data->tag, CCM_BLOCKSIZE);
}
// Process the remaining data in the last update.
static uint32_t CcmLastHandle(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
{
uint32_t lastLen = (ctx->lastLen < len) ? ctx->lastLen : len;
if (ctx->lastLen > 0) {
XorCryptData data;
data.in = in;
data.out = out;
data.ctr = &(ctx->last[CCM_BLOCKSIZE - ctx->lastLen]);
data.tag = &(ctx->tag[CCM_BLOCKSIZE - ctx->lastLen]);
if (enc) {
XorInEncrypt(&data, lastLen);
} else {
XorInDecrypt(&data, lastLen);
}
// Refresh the remaining length.
// The judgment of the function entry ensures that lastLen does not exceed ctx->lastLen,
// and this forcible transition does not occur truncation.
ctx->lastLen -= (uint8_t)lastLen;
}
return lastLen;
}
static void RefreshNonce(MODES_CipherCCMCtx *ctx)
{
if ((ctx->nonce[0] & (~0x07)) != 0) {
/**
* RFC_3610-2.3
* Bit Number Contents
* ---------- ----------------------
* 7 Reserved (always zero)
* 6 Reserved (always zero)
* 5 ... 3 Zero
* 2 ... 0 L'
*/
ctx->nonce[0] &= 0x07;
/**
* RFC_3610-2.3
* Octet Number Contents
* ------------ ---------
* 0 Flags
* 1 ... 15-L Nonce N
* 16-L ... 15 Counter i
*/
uint8_t i;
uint8_t l = ctx->nonce[0] + 1;
for (i = 1; i < l; i++) {
ctx->nonce[CCM_BLOCKSIZE - 1 - i] = 0;
}
/**
* RFC_3610-2.3
* The message is encrypted by XORing the octets of message m with the
* first l(m) octets of the concatenation of S_1, S_2, S_3, ... . Note
* that S_0 is not used to encrypt the message.
*/
ctx->nonce[CCM_BLOCKSIZE - 1] = 1;
}
}
static int32_t TagInit(MODES_CipherCCMCtx *ctx)
{
if (ctx->tagInit == 0) {
int32_t ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->nonce, ctx->tag, CCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ctx->tagInit = 1;
}
return CRYPT_SUCCESS;
}
static int32_t CcmBlocks(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
{
XorCryptData data;
data.in = in;
data.out = out;
data.ctr = ctx->last;
data.tag = ctx->tag;
uint8_t countLen = (ctx->nonce[0] & 0x07) + 1;
uint32_t dataLen = len;
void (*xorBlock)(XorCryptData *data) = enc ? XorInEncryptBlock : XorInDecryptBlock;
void (*xor)(XorCryptData *data, uint32_t len) = enc ? XorInEncrypt : XorInDecrypt;
while (dataLen >= CCM_BLOCKSIZE) { // process the integer multiple of 16bytes data
(void)ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->nonce, ctx->last, CCM_BLOCKSIZE);
xorBlock(&data);
(void)ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->tag, ctx->tag, CCM_BLOCKSIZE);
MODE_IncCounter(ctx->nonce + CCM_BLOCKSIZE - countLen, countLen); // counter +1
dataLen -= CCM_BLOCKSIZE;
data.in += CCM_BLOCKSIZE;
data.out += CCM_BLOCKSIZE;
}
if (dataLen > 0) { // process the integer multiple of 16bytes data
(void)ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->nonce, ctx->last, CCM_BLOCKSIZE);
xor(&data, dataLen);
MODE_IncCounter(ctx->nonce + CCM_BLOCKSIZE - countLen, countLen); // counter +1
}
return CRYPT_SUCCESS;
}
// Enc: true for encryption and false for decryption.
int32_t CcmCrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc, const CcmCore func)
{
if (ctx == NULL || ctx->ciphCtx == NULL || in == NULL || out == NULL || len == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len > ctx->msgLen) {
// The message length is exceeded.
BSL_ERR_PUSH_ERROR(CRYPT_MODES_MSGLEN_OVERFLOW);
return CRYPT_MODES_MSGLEN_OVERFLOW;
}
int32_t ret = TagInit(ctx);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
// Determine whether to start encryption and update the nonce information.
RefreshNonce(ctx);
uint32_t lastLen = CcmLastHandle(ctx, in, out, len, enc);
if (lastLen != 0 && ctx->lastLen == 0) {
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->tag, ctx->tag, CCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
}
// Data processing is complete and exits in advance.
if (lastLen == len) {
ctx->msgLen -= len; // Refresh the remaining length.
return CRYPT_SUCCESS;
}
uint32_t tmpLen = len - lastLen;
ret = func(ctx, in + lastLen, out + lastLen, tmpLen, enc);
if (ret != CRYPT_SUCCESS) {
// Returned by the internal function. No redundant push err is required.
return ret;
}
ctx->lastLen = (CCM_BLOCKSIZE - (tmpLen % CCM_BLOCKSIZE)) % CCM_BLOCKSIZE;
ctx->msgLen -= len; // Refresh the remaining length.
return CRYPT_SUCCESS;
}
int32_t MODES_CCM_Encrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
return CcmCrypt(ctx, in, out, len, true, CcmBlocks);
}
int32_t MODES_CCM_Decrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
return CcmCrypt(ctx, in, out, len, false, CcmBlocks);
}
// 7 <= ivLen <= 13
static int32_t SetIv(MODES_CipherCCMCtx *ctx, const void *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
/**
* RFC_3610-2
* Valid values of L range between 2 octets and 8 octets
*/
// L = 15 - ivLen that is 7 <= ivLen <= 13
if (len < 7 || len > 13) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_IVLEN_ERROR);
return CRYPT_MODES_IVLEN_ERROR;
}
// The previous judgment limits the size of iv to [7, 13]. Therefore, forcible conversion does not cause truncation.
uint8_t l = CCM_BLOCKSIZE - 1 - (uint8_t)len;
// Clear data.
void *ciphCtx = ctx->ciphCtx; // Handle used by the method
const EAL_SymMethod *ciphMeth = ctx->ciphMeth; // algorithm method
uint8_t tagLen = ctx->tagLen;
(void)memset_s(ctx, sizeof(MODES_CipherCCMCtx), 0, sizeof(MODES_CipherCCMCtx));
ctx->ciphCtx = ciphCtx;
ctx->ciphMeth = ciphMeth;
ctx->tagLen = tagLen;
uint8_t m = (ctx->tagLen - 2) / 2; // M' = (M - 2)/2
ctx->nonce[0] = (uint8_t)((l - 1) & 0x7); // set L
ctx->nonce[0] |= (m << 3); // set M. The default value of TagLen is 16bytes. (bit2 bit3 bit4) indicating the tagLen
(void)memcpy_s(ctx->nonce + 1, CCM_BLOCKSIZE - 1, val, len);
return CRYPT_SUCCESS;
}
// The input data is the uint64_t.
static int32_t SetMsgLen(MODES_CipherCCMCtx *ctx, const void *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != sizeof(uint64_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_MSGLEN_ERROR);
return CRYPT_MODES_CTRL_MSGLEN_ERROR;
}
if ((ctx->nonce[0] & 0x40) != 0) {
// If aad has been set, msgLen cannot be set.
BSL_ERR_PUSH_ERROR(CRYPT_MODES_AAD_IS_SET_ERROR);
return CRYPT_MODES_AAD_IS_SET_ERROR;
}
const uint64_t msgLen = *(const uint64_t *)val;
uint8_t l = (ctx->nonce[0] & 0x7) + 1;
/**
* RFC_3610-7
* octet aligned message of arbitrary length, up to 2^(8*L) octets,
* and octet aligned arbitrary additional authenticated data, up to
* 2^64 octets
*/
if (l < 8 && msgLen >= ((uint64_t)1 << (8 * l))) { // When l is 8, the condition must be met.
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_MSGLEN_ERROR);
return CRYPT_MODES_CTRL_MSGLEN_ERROR;
}
uint8_t i;
/**
* RFC_3610-2.3
* Octet Number Contents
* ------------ ---------
* 0 Flags
* 1 ... 15-L Nonce N
* 16-L ... 15 Counter i
*/
uint8_t bytes[sizeof(uint64_t)];
Uint64ToBeBytes(msgLen, bytes);
for (i = 0; i < l; i++) {
ctx->nonce[CCM_BLOCKSIZE - 1 - i] = bytes[8 - 1 - i]; // 8 bit msgLen information
}
ctx->msgLen = msgLen;
return CRYPT_SUCCESS;
}
static int32_t SetTagLen(MODES_CipherCCMCtx *ctx, const void *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != sizeof(uint32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TAGLEN_ERROR);
return CRYPT_MODES_CTRL_TAGLEN_ERROR;
}
if ((ctx->nonce[0] & 0x40) != 0) {
// If aad has been set, tagLen cannot be set.
BSL_ERR_PUSH_ERROR(CRYPT_MODES_AAD_IS_SET_ERROR);
return CRYPT_MODES_AAD_IS_SET_ERROR;
}
/**
* RFC_3610-2
* Valid values are 4, 6, 8, 10, 12, 14, and 16 octets
*/
uint32_t tagLen = *((const uint32_t *)val);
// 4 <= tagLen <= 16 and tagLen is an even number.
if (tagLen > 16 || tagLen < 4 || ((tagLen & 0x01) != 0)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TAGLEN_ERROR);
return CRYPT_MODES_CTRL_TAGLEN_ERROR;
}
ctx->tagLen = (uint8_t)tagLen;
uint8_t m = (ctx->tagLen - 2) / 2; // M' = (M - 2)/2
ctx->nonce[0] &= ~(0x7 << 3); // Clear 3|4|5 three bits
ctx->nonce[0] |= (m << 3); // Set M
return CRYPT_SUCCESS;
}
static uint32_t XorAadLen(MODES_CipherCCMCtx *ctx, uint32_t aadLen)
{
/**
* RFC_3610-2.2
* First two octets Followed by Comment
* ----------------- ---------------- -------------------------------
* 0x0000 Nothing Reserved
* 0x0001 ... 0xFEFF Nothing For 0 < l(a) < (2^16 - 2^8)
* 0xFF00 ... 0xFFFD Nothing Reserved
* 0xFFFE 4 octets of l(a) For (2^16 - 2^8) <= l(a) < 2^32
* 0xFFFF 8 octets of l(a) For 2^32 <= l(a) < 2^64
*/
uint32_t record; /* In order to record aadlen */
// For 0 < l(a) < (2^16 - 2^8)
if (aadLen < (((size_t)1 << 16) - ((size_t)1 << 8))) {
/* 0 < l(a) < (2^16 - 2^8) */
record = 2; /* 2 octets */
ctx->tag[1] ^= (uint8_t)aadLen;
ctx->tag[0] ^= (uint8_t)(aadLen >> 8); // 1byte = 8bit
} else {
/* (2^16 - 2^8) <= l(a) < 2^32 */
record = 6; /* 6 octets */
ctx->tag[5] ^= (uint8_t)aadLen; // base offset = 5
ctx->tag[4] ^= (uint8_t)(aadLen >> 8); // 1byte(off 5 -> 4) == 8bit
ctx->tag[3] ^= (uint8_t)(aadLen >> 16); // 2byte(off 5 -> 3) == 16bit
ctx->tag[2] ^= (uint8_t)(aadLen >> 24); // 3byte(off 5 -> 2) == 24bit
ctx->tag[1] ^= 0xfe;
ctx->tag[0] ^= 0xff;
}
return record;
}
// 0 < aadLen < 2^32
static int32_t SetAad(MODES_CipherCCMCtx *ctx, const void *val, uint32_t len)
{
if ((ctx->nonce[0] & 0x40) != 0 || ctx->tagInit != 0) {
// If aad has been set, the setting cannot be repeated.
BSL_ERR_PUSH_ERROR(CRYPT_MODES_AAD_REPEAT_SET_ERROR);
return CRYPT_MODES_AAD_REPEAT_SET_ERROR;
}
if (len == 0) { // If AAD is 0, returned directly.
return CRYPT_SUCCESS;
}
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
// bit6 Adata
ctx->nonce[0] |= 0x40;
// X_1 := E( K, B_0 )
int32_t ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->nonce, ctx->tag, CCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ctx->tagInit = 1;
uint32_t i;
uint32_t aadLen = len;
uint32_t record = XorAadLen(ctx, aadLen);
const uint8_t *aad = val;
uint32_t use = CCM_BLOCKSIZE - record;
use = (use < aadLen) ? use : aadLen;
for (i = 0; i < use; i++) {
ctx->tag[i + record] ^= aad[i];
}
aad += use;
aadLen -= use;
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->tag, ctx->tag, CCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
while (aadLen > 0) {
uint32_t blockLen = (aadLen < CCM_BLOCKSIZE) ? aadLen : CCM_BLOCKSIZE;
for (i = 0; i < blockLen; i++) {
ctx->tag[i] ^= aad[i];
}
aad += blockLen;
aadLen -= blockLen;
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->tag, ctx->tag, CCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
}
return CRYPT_SUCCESS;
}
static int32_t CtrTagCalc(MODES_CipherCCMCtx *ctx)
{
/**
* RFC_3610-2.3
* The authentication value U is computed by encrypting T with the ciphCtx
* stream block S_0 and truncating it to the desired length.
*/
ctx->nonce[0] &= 0x07; // update the nonce
uint8_t l = (ctx->nonce[0] & 0x07) + 1;
(void)memset_s(ctx->nonce + CCM_BLOCKSIZE - l, l, 0, l);
int32_t ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->nonce, ctx->nonce, CCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
static int32_t GetTag(MODES_CipherCCMCtx *ctx, void *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != ctx->tagLen) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_TAGLEN_ERROR);
return CRYPT_MODES_TAGLEN_ERROR;
}
if (ctx->msgLen != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_MSGLEN_LEFT_ERROR);
return CRYPT_MODES_MSGLEN_LEFT_ERROR;
}
int32_t ret = TagInit(ctx);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = CtrTagCalc(ctx);
if (ret != CRYPT_SUCCESS) {
// An error is reported by the internal function, and no redundant pushErr is required.
return ret;
}
if (ctx->lastLen != 0) {
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->tag, ctx->tag, CCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
}
uint32_t i;
uint8_t *tag = val;
/**
* RFC_3610-2.3
* U := T XOR first-M-bytes( S_0 )
*/
for (i = 0; i < len; i++) {
tag[i] = ctx->tag[i] ^ ctx->nonce[i];
}
return CRYPT_SUCCESS;
}
int32_t MODES_CCM_Ctrl(MODES_CCM_Ctx *modeCtx, int32_t opt, void *val, uint32_t len)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (opt) {
case CRYPT_CTRL_SET_IV:
case CRYPT_CTRL_REINIT_STATUS:
return SetIv(&modeCtx->ccmCtx, val, len);
case CRYPT_CTRL_GET_BLOCKSIZE:
if (val == NULL || len != sizeof(uint32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
*(int32_t *)val = 1;
return CRYPT_SUCCESS;
case CRYPT_CTRL_SET_TAGLEN:
return SetTagLen(&modeCtx->ccmCtx, val, len);
case CRYPT_CTRL_SET_MSGLEN:
return SetMsgLen(&modeCtx->ccmCtx, val, len);
case CRYPT_CTRL_SET_AAD:
return SetAad(&modeCtx->ccmCtx, val, len);
case CRYPT_CTRL_GET_TAG:
return GetTag(&modeCtx->ccmCtx, val, len);
default:
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TYPE_ERROR);
return CRYPT_MODES_CTRL_TYPE_ERROR;
}
}
MODES_CCM_Ctx *MODES_CCM_NewCtx(int32_t algId)
{
const EAL_SymMethod *method = EAL_GetSymMethod(algId);
if (method == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return NULL;
}
MODES_CCM_Ctx *ctx = BSL_SAL_Calloc(1, sizeof(MODES_CCM_Ctx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return ctx;
}
ctx->algId = algId;
ctx->ccmCtx.ciphCtx = BSL_SAL_Calloc(1, method->ctxSize);
if (ctx->ccmCtx.ciphCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
BSL_SAL_Free(ctx);
return NULL;
}
ctx->ccmCtx.ciphMeth = method;
return ctx;
}
int32_t MODES_CCM_InitCtx(MODES_CCM_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, void *param, bool enc)
{
(void)param;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = modeCtx->ccmCtx.ciphMeth->setEncryptKey(modeCtx->ccmCtx.ciphCtx, key, keyLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
modeCtx->ccmCtx.tagLen = 16; // 16 default tag len, set iv need
ret = SetIv(&modeCtx->ccmCtx, iv, ivLen);
if (ret != CRYPT_SUCCESS) {
modeCtx->ccmCtx.ciphMeth->cipherDeInitCtx(modeCtx->ccmCtx.ciphCtx);
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
modeCtx->enc = enc;
return ret;
}
int32_t MODES_CCM_Update(MODES_CCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? MODES_CCM_Encrypt : MODES_CCM_Decrypt, &modeCtx->ccmCtx,
in, inLen, out, outLen);
}
int32_t MODES_CCM_Final(MODES_CCM_Ctx *modeCtx, uint8_t *out, uint32_t *outLen)
{
(void) modeCtx;
(void) out;
(void) outLen;
return CRYPT_EAL_CIPHER_FINAL_WITH_AEAD_ERROR;
}
int32_t MODES_CCM_DeInitCtx(MODES_CCM_Ctx *modeCtx)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
const EAL_SymMethod *ciphMeth = modeCtx->ccmCtx.ciphMeth;
void *ciphCtx = modeCtx->ccmCtx.ciphCtx;
modeCtx->ccmCtx.ciphMeth->cipherDeInitCtx(modeCtx->ccmCtx.ciphCtx);
BSL_SAL_CleanseData(&modeCtx->ccmCtx, sizeof(MODES_CipherCCMCtx));
modeCtx->ccmCtx.ciphMeth = ciphMeth;
modeCtx->ccmCtx.ciphCtx = ciphCtx;
return CRYPT_SUCCESS;
}
void MODES_CCM_FreeCtx(MODES_CCM_Ctx *modeCtx)
{
if (modeCtx == NULL) {
return;
}
modeCtx->ccmCtx.ciphMeth->cipherDeInitCtx(modeCtx->ccmCtx.ciphCtx);
BSL_SAL_FREE(modeCtx->ccmCtx.ciphCtx);
BSL_SAL_CleanseData(&modeCtx->ccmCtx, sizeof(MODES_CipherCCMCtx));
BSL_SAL_FREE(modeCtx);
}
int32_t MODES_CCM_UpdateEx(MODES_CCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_AES128_CCM:
case CRYPT_CIPHER_AES192_CCM:
case CRYPT_CIPHER_AES256_CCM:
#ifdef HITLS_CRYPTO_AES
return AES_CCM_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_CCM_Update(modeCtx, in, inLen, out, outLen);
}
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/modes_ccm.c | C | unknown | 20,629 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CFB
#include <stdbool.h>
#include "securec.h"
#include "bsl_err_internal.h"
#include "bsl_sal.h"
#include "crypt_modes_cfb.h"
#include "modes_local.h"
#include "crypt_errno.h"
#include "crypt_local_types.h"
#include "crypt_modes.h"
/* 8-bit | 64-bit | 128-bit CFB encryption. Here, len indicates the number of bytes to be processed. */
static int32_t MODES_CFB_BytesEncrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
const uint8_t *input = in;
uint8_t *output = out;
uint8_t *tmp = ctx->modeCtx.buf;
uint32_t blockSize = ctx->modeCtx.blockSize;
uint32_t feedbackBytes = ctx->feedbackBits >> 3; // right shifting by 3 to obtain the number of bytes.
uint32_t left = len;
uint32_t i, k;
// If the remaining encryption iv is not used up last time, use that part to perform XOR.
while (left > 0 && ctx->modeCtx.offset > 0) {
ctx->modeCtx.iv[ctx->modeCtx.offset] ^= *(input++);
*(output++) = ctx->modeCtx.iv[ctx->modeCtx.offset];
left--;
ctx->modeCtx.offset = (ctx->modeCtx.offset + 1) % blockSize;
}
while (left > 0) {
// Encrypt the IV.
int32_t ret = ctx->modeCtx.ciphMeth->encryptBlock(ctx->modeCtx.ciphCtx, ctx->modeCtx.iv, tmp, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
i = 0;
// The first (blockSize - feedbackBytes) bytes are filled with the least significant bytes of the previous IV.
if (blockSize - feedbackBytes > 0) {
(void)memmove_s(&ctx->modeCtx.iv[0], blockSize, &ctx->modeCtx.iv[feedbackBytes],
blockSize - feedbackBytes);
i = blockSize - feedbackBytes;
}
// The input data is XORed with the encrypted IV, and the current ciphertext is sent to the next IV.
if (left >= feedbackBytes) {
// Enter the last feedbackBytes in ciphertext.
for (k = 0; i < blockSize; i++, k++) {
output[k] = input[k] ^ tmp[k];
ctx->modeCtx.iv[i] = output[k];
}
UPDATE_VALUES(left, input, output, feedbackBytes);
} else {
// Enter the last feedbackBytes in ciphertext.
// The cache with insufficient feedbackBytes is used to encrypt the IV.
for (k = 0; k < left; k++) {
output[k] = input[k] ^ tmp[k];
ctx->modeCtx.iv[i++] = output[k];
}
while (i < blockSize) {
ctx->modeCtx.iv[i++] = tmp[k++];
}
ctx->modeCtx.offset = (uint8_t)(blockSize - feedbackBytes + left);
left = 0;
}
}
return CRYPT_SUCCESS;
}
static int32_t MODES_CFB128_BytesEncrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
const uint8_t *inp = in;
uint8_t *outp = out;
uint32_t blockSize = ctx->modeCtx.blockSize;
uint8_t *iv = ctx->modeCtx.iv;
uint32_t left = len;
int32_t ret;
while (left > 0 && ctx->modeCtx.offset > 0) {
iv[ctx->modeCtx.offset] ^= *(inp++);
*(outp++) = iv[ctx->modeCtx.offset];
left--;
ctx->modeCtx.offset = (ctx->modeCtx.offset + 1) % blockSize;
}
while (left >= blockSize) {
ret = ctx->modeCtx.ciphMeth->encryptBlock(ctx->modeCtx.ciphCtx, iv, iv, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
#ifdef FORCE_ADDR_ALIGN
for (uint32_t i = 0; i < blockSize; i++) {
iv[i] ^= inp[i];
out[i] = iv[i];
}
#else
for (uint32_t i = 0; i < blockSize; i += sizeof(uint64_t)) {
*((uint64_t *)(iv + i)) ^= *((const uint64_t *)(inp + i));
*((uint64_t *)(outp + i)) = *((uint64_t *)(iv + i));
}
#endif
UPDATE_VALUES(left, inp, outp, blockSize);
}
if (left > 0) {
ret = ctx->modeCtx.ciphMeth->encryptBlock(ctx->modeCtx.ciphCtx, iv, iv, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
uint32_t i = 0;
for (; i < left; i++) {
iv[i] ^= inp[i];
outp[i] = iv[i];
}
ctx->modeCtx.offset = (uint8_t)left;
}
return CRYPT_SUCCESS;
}
/* 8-bit | 64-bit | 128-bit CFB decryption. Here, len indicates the number of bytes to be processed. */
static int32_t MODES_CFB_BytesDecrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
const uint8_t *input = in;
uint8_t *output = out;
uint8_t *tmp = ctx->modeCtx.buf;
uint32_t blockSize = ctx->modeCtx.blockSize;
uint32_t feedbackBytes = ctx->feedbackBits >> 3;
uint32_t left = len;
uint32_t i, k;
// If the remaining encryption iv is not used up last time, use that part to perform XOR.
while (left > 0 && ctx->modeCtx.offset > 0) {
uint8_t tmpInput = *input; // To support the same address in and out
*(output++) = ctx->modeCtx.iv[ctx->modeCtx.offset] ^ *(input++);
ctx->modeCtx.iv[ctx->modeCtx.offset] = tmpInput;
left--;
ctx->modeCtx.offset = (ctx->modeCtx.offset + 1) % blockSize;
}
while (left > 0) {
// Encrypt the IV.
int32_t ret = ctx->modeCtx.ciphMeth->encryptBlock(ctx->modeCtx.ciphCtx, ctx->modeCtx.iv, tmp, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
i = 0;
// The first (blockSize - feedbackBytes) bytes are filled with the least significant bytes of the previous IV.
if (blockSize - feedbackBytes > 0) {
(void)memmove_s(&ctx->modeCtx.iv[0], blockSize, &ctx->modeCtx.iv[feedbackBytes],
blockSize - feedbackBytes);
i = blockSize - feedbackBytes;
}
// The input data is XORed with the encrypted IV, and the current ciphertext is sent to the next IV.
if (left >= feedbackBytes) {
// Enter the last feedbackBytes in ciphertext.
for (k = 0; i < blockSize; i++, k++) {
ctx->modeCtx.iv[i] = input[k];
output[k] = input[k] ^ tmp[k];
}
UPDATE_VALUES(left, input, output, feedbackBytes);
} else {
// Enter the last feedbackBytes in ciphertext.
// The cache with insufficient feedbackBytes is used to encrypt the IV.
for (k = 0; k < left; k++) {
ctx->modeCtx.iv[i++] = input[k];
output[k] = input[k] ^ tmp[k];
}
while (i < blockSize) {
ctx->modeCtx.iv[i++] = tmp[k++];
}
ctx->modeCtx.offset = (uint8_t)(blockSize - feedbackBytes + left);
left = 0;
}
}
return CRYPT_SUCCESS;
}
static int32_t MODES_CFB128_BytesDecrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
const uint8_t *inp = in;
uint8_t *outp = out;
uint8_t *iv = ctx->modeCtx.iv;
uint32_t blockSize = ctx->modeCtx.blockSize;
uint32_t left = len;
int32_t ret;
while (left > 0 && ctx->modeCtx.offset > 0) {
uint8_t tmpInput = *inp; // To support the same address in and out
*(outp++) = iv[ctx->modeCtx.offset] ^ *(inp++);
iv[ctx->modeCtx.offset] = tmpInput;
left--;
ctx->modeCtx.offset = (ctx->modeCtx.offset + 1) % blockSize;
}
while (left >= blockSize) {
ret = ctx->modeCtx.ciphMeth->encryptBlock(ctx->modeCtx.ciphCtx, iv, iv, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
#ifdef FORCE_ADDR_ALIGN
for (uint32_t i = 0; i < blockSize; i++) {
uint8_t c = inp[i];
outp[i] = iv[i] ^ c;
iv[i] = c;
}
#else
for (uint32_t i = 0; i < blockSize; i += sizeof(uint64_t)) {
uint64_t ti = *((const uint64_t *)(inp + i));
*((uint64_t *)(outp + i)) = *((uint64_t *)(iv + i)) ^ ti;
*((uint64_t *)(iv + i)) = ti;
}
#endif
UPDATE_VALUES(left, inp, outp, blockSize);
}
if (left > 0) {
ret = ctx->modeCtx.ciphMeth->encryptBlock(ctx->modeCtx.ciphCtx, iv, iv, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
uint32_t i = 0;
for (; i < left; i++) {
uint8_t b = inp[i];
outp[i] = iv[i] ^ b;
iv[i] = b;
}
ctx->modeCtx.offset = (uint8_t)left;
}
return CRYPT_SUCCESS;
}
static int32_t Cfb1Crypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, bool enc)
{
int32_t ret;
uint8_t *tmp = ctx->modeCtx.buf;
uint32_t blockSize = ctx->modeCtx.blockSize;
uint32_t i;
// Encrypt the IV.
ret = ctx->modeCtx.ciphMeth->encryptBlock(ctx->modeCtx.ciphCtx, ctx->modeCtx.iv, tmp, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
for (i = 0; i < blockSize - 1; i++) {
// All bytes are shifted left by one bit,
// and the least significant bits are obtained by shifting right by 7 bits from the next byte.
ctx->modeCtx.iv[i] = (ctx->modeCtx.iv[i] << 1) | (ctx->modeCtx.iv[i + 1] >> 7);
}
if (enc) {
*out = tmp[0] ^ *in;
// The last byte is shifted to the left by one bit and then filled in the ciphertext.
// Shifted to the right by 7 bits to obtain the first bit of the byte.
ctx->modeCtx.iv[i] = (ctx->modeCtx.iv[i] << 1) | (*out >> 7);
} else {
// The last byte is shifted to the left by one bit and then filled in the ciphertext.
// Shifted to the right by 7 bits to obtain the first bit of the byte.
ctx->modeCtx.iv[i] = (ctx->modeCtx.iv[i] << 1) | (*in >> 7);
*out = tmp[0] ^ *in;
}
return CRYPT_SUCCESS;
}
/* 1-bit CFB. Here, len indicates the number of bits to be processed. */
int32_t MODES_CFB_BitCrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
{
int32_t ret;
uint8_t tmp[2];
uint32_t pos;
for (uint32_t i = 0; i < len; i++) {
// 7 - i % 8 is used to obtain the number of bits in the byte stream (high bit -> low bit).
pos = 7 - i % 8;
// Obtain the bits to be encrypted. 0x80 indicates a byte whose most significant bit is 1.
tmp[0] = ((in[i / 8] & (1 << pos)) > 0) ? 0x80 : 0;
ret = Cfb1Crypt(ctx, &tmp[0], &tmp[1], enc);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
// Divide by 8 to obtain the current byte position. Assign the out encryption bit to 0.
out[i / 8] = out[i / 8] & ~(1u << pos);
// Divide by 8 to obtain the current byte position. tmpOut[0] >> 7 to obtain the most significant bit.
out[i / 8] |= (tmp[1] >> 7) << pos; // Assign the out encryption bit to the encrypted/decrypted value.
}
(void)memset_s(tmp, sizeof(tmp), 0, sizeof(tmp));
return CRYPT_SUCCESS;
}
int32_t MODES_CFB_Encrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL || len == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (ctx->feedbackBits) {
case 1:
return MODES_CFB_BitCrypt(ctx, in, out, len * 8, true); // Each byte occupies 8 bits.
case 8:
case 64:
return MODES_CFB_BytesEncrypt(ctx, in, out, len);
case 128:
return MODES_CFB128_BytesEncrypt(ctx, in, out, len);
default:
BSL_ERR_PUSH_ERROR(CRYPT_MODES_ERR_FEEDBACKSIZE);
return CRYPT_MODES_ERR_FEEDBACKSIZE;
}
}
int32_t MODES_CFB_Decrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL || len == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (ctx->feedbackBits) {
case 1: // 1-bit cfb. Convert the length of bytes to the length of bits.
return MODES_CFB_BitCrypt(ctx, in, out, len * 8, false); // Each byte occupies 8 bits.
case 8: // 8-bit cfb
case 64: // 64-bit cfb
return MODES_CFB_BytesDecrypt(ctx, in, out, len);
case 128: // 128-bit cfb
return MODES_CFB128_BytesDecrypt(ctx, in, out, len);
default:
BSL_ERR_PUSH_ERROR(CRYPT_MODES_ERR_FEEDBACKSIZE);
return CRYPT_MODES_ERR_FEEDBACKSIZE;
}
}
static int32_t SetFeedbackSize(MODES_CipherCFBCtx *ctx, const uint32_t *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != sizeof(uint32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
if (*val != 1 && *val != 8 && *val != 64 && *val != 128) { // set 1|8|64|128 feedbackbits only
BSL_ERR_PUSH_ERROR(CRYPT_MODES_ERR_FEEDBACKSIZE);
return CRYPT_MODES_ERR_FEEDBACKSIZE;
}
if (*val > (uint32_t)(ctx->modeCtx.blockSize * 8)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_ERR_FEEDBACKSIZE);
return CRYPT_MODES_ERR_FEEDBACKSIZE;
}
ctx->feedbackBits = (uint8_t)*val;
return CRYPT_SUCCESS;
}
static int32_t GetFeedbackSize(MODES_CipherCFBCtx *ctx, uint32_t *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != sizeof(uint32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
*val = ctx->feedbackBits;
return CRYPT_SUCCESS;
}
int32_t MODES_CFB_Ctrl(MODES_CFB_Ctx *modeCtx, int32_t opt, void *val, uint32_t len)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (opt) {
case CRYPT_CTRL_REINIT_STATUS:
modeCtx->cfbCtx.cacheIndex = 0;
return MODES_SetIv(&modeCtx->cfbCtx.modeCtx, val, len);
case CRYPT_CTRL_GET_IV:
return MODES_GetIv(&modeCtx->cfbCtx.modeCtx, (uint8_t *)val, len);
case CRYPT_CTRL_SET_FEEDBACKSIZE:
return SetFeedbackSize(&modeCtx->cfbCtx, (uint32_t *)val, len);
case CRYPT_CTRL_GET_FEEDBACKSIZE:
return GetFeedbackSize(&modeCtx->cfbCtx, (uint32_t *)val, len);
case CRYPT_CTRL_GET_BLOCKSIZE:
if (val == NULL || len != sizeof(uint32_t)) {
return CRYPT_INVALID_ARG;
}
*(int32_t *)val = 1;
return CRYPT_SUCCESS;
default:
if (modeCtx->cfbCtx.modeCtx.ciphMeth == NULL ||
modeCtx->cfbCtx.modeCtx.ciphMeth->cipherCtrl == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TYPE_ERROR);
return CRYPT_MODES_CTRL_TYPE_ERROR;
}
return modeCtx->cfbCtx.modeCtx.ciphMeth->cipherCtrl(modeCtx->cfbCtx.modeCtx.ciphCtx, opt, val, len);
}
}
MODES_CFB_Ctx *MODES_CFB_NewCtx(int32_t algId)
{
const EAL_SymMethod *method = EAL_GetSymMethod(algId);
if (method == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return NULL;
}
MODES_CFB_Ctx *ctx = BSL_SAL_Calloc(1, sizeof(MODES_CFB_Ctx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return ctx;
}
ctx->algId = algId;
ctx->cfbCtx.modeCtx.ciphCtx = BSL_SAL_Calloc(1, method->ctxSize);
if (ctx->cfbCtx.modeCtx.ciphCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
BSL_SAL_Free(ctx);
return NULL;
}
ctx->cfbCtx.cacheIndex = 0;
uint8_t blockBits = method->blockSize * 8;
if (blockBits <= 128) {
ctx->cfbCtx.feedbackBits = blockBits;
} else {
ctx->cfbCtx.feedbackBits = 128;
}
ctx->cfbCtx.modeCtx.blockSize = method->blockSize;
ctx->cfbCtx.modeCtx.ciphMeth = method;
ctx->cfbCtx.modeCtx.offset = 0;
return ctx;
}
int32_t MODES_CFB_InitCtx(MODES_CFB_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
modeCtx->cfbCtx.cacheIndex = 0;
modeCtx->enc = enc;
return MODES_CipherInitCommonCtx(&modeCtx->cfbCtx.modeCtx, modeCtx->cfbCtx.modeCtx.ciphMeth->setEncryptKey,
modeCtx->cfbCtx.modeCtx.ciphCtx, key, keyLen, iv, ivLen);
}
int32_t MODES_CFB_Update(MODES_CFB_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? MODES_CFB_Encrypt : MODES_CFB_Decrypt, &modeCtx->cfbCtx,
in, inLen, out, outLen);
}
int32_t MODES_CFB_Final(MODES_CFB_Ctx *modeCtx, uint8_t *out, uint32_t *outLen)
{
(void) modeCtx;
(void) out;
*outLen = 0;
return CRYPT_SUCCESS;
}
int32_t MODES_CFB_DeInitCtx(MODES_CFB_Ctx *modeCtx)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
MODES_Clean(&modeCtx->cfbCtx.modeCtx);
BSL_SAL_CleanseData((void *)(modeCtx->cfbCtx.cipherCache[0]), DES_BLOCK_BYTE_NUM * 3); // 3 ciphertext caches
return CRYPT_SUCCESS;
}
void MODES_CFB_FreeCtx(MODES_CFB_Ctx *modeCtx)
{
if (modeCtx == NULL) {
return ;
}
(void)MODES_CFB_DeInitCtx(modeCtx);
BSL_SAL_Free(modeCtx->cfbCtx.modeCtx.ciphCtx);
BSL_SAL_Free(modeCtx);
}
int32_t MODES_CFB_InitCtxEx(MODES_CFB_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, void *param, bool enc)
{
(void) param;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ivLen != modeCtx->cfbCtx.modeCtx.blockSize) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_IVLEN_ERROR);
return CRYPT_MODES_IVLEN_ERROR;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_SM4_CFB:
#ifdef HITLS_CRYPTO_SM4
return SM4_CFB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_CFB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
}
int32_t MODES_CFB_UpdateEx(MODES_CFB_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_AES128_CFB:
case CRYPT_CIPHER_AES192_CFB:
case CRYPT_CIPHER_AES256_CFB:
#ifdef HITLS_CRYPTO_AES
return AES_CFB_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
case CRYPT_CIPHER_SM4_CFB:
#ifdef HITLS_CRYPTO_SM4
return SM4_CFB_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_CFB_Update(modeCtx, in, inLen, out, outLen);
}
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/modes_cfb.c | C | unknown | 19,758 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
#include <stdint.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "modes_local.h"
#include "poly1305_core.h"
#include "crypt_modes.h"
void Poly1305SetKey(Poly1305Ctx *ctx, const uint8_t key[POLY1305_KEYSIZE])
{
// RFC_7539-2.5
ctx->r[0] = GET_UINT32_LE(key, 0);
ctx->r[1] = GET_UINT32_LE(key, 4);
ctx->r[2] = GET_UINT32_LE(key, 8);
ctx->r[3] = GET_UINT32_LE(key, 12);
ctx->s[0] = GET_UINT32_LE(key, 16);
ctx->s[1] = GET_UINT32_LE(key, 20);
ctx->s[2] = GET_UINT32_LE(key, 24);
ctx->s[3] = GET_UINT32_LE(key, 28);
/**
* r[3], r[7], r[11], and r[15] are required to have their top four
* bits clear (be smaller than 16)
* r[4], r[8], and r[12] are required to have their bottom two bits
* clear (be divisible by 4)
*/
ctx->r[0] &= 0x0FFFFFFF;
ctx->r[1] &= 0x0FFFFFFC;
ctx->r[2] &= 0x0FFFFFFC;
ctx->r[3] &= 0x0FFFFFFC;
ctx->acc[0] = 0;
ctx->acc[1] = 0;
ctx->acc[2] = 0;
ctx->acc[3] = 0;
ctx->acc[4] = 0;
ctx->acc[5] = 0;
(void)memset_s(ctx->last, sizeof(ctx->last), 0, sizeof(ctx->last));
ctx->lastLen = 0;
Poly1305InitForAsm(ctx); // Information such as tables required for initializing the assembly
}
void Poly1305Update(Poly1305Ctx *ctx, const uint8_t *data, uint32_t dataLen)
{
uint32_t i;
uint32_t len = dataLen;
const uint8_t *off = data;
if (ctx->lastLen != 0) {
uint64_t end = (uint64_t)len + ctx->lastLen;
if (end > POLY1305_BLOCKSIZE) {
end = POLY1305_BLOCKSIZE;
}
for (i = ctx->lastLen; i < end; i++) {
ctx->last[i] = *off;
off++;
}
len -= (uint32_t)(end - ctx->lastLen);
if (end == POLY1305_BLOCKSIZE) {
(void)Poly1305Block(ctx, ctx->last, POLY1305_BLOCKSIZE, 1);
} else {
ctx->lastLen = (uint32_t)end;
return;
}
}
/**
* Add one bit beyond the number of octets. For a 16-byte block,
* this is equivalent to adding 2^128 to the number.
*/
if (len >= POLY1305_BLOCKSIZE) {
(void)Poly1305Block(ctx, off, len & 0xfffffff0, 1);
}
ctx->lastLen = len & 0x0f; // mod 16;
off += len - ctx->lastLen;
for (i = 0; i < ctx->lastLen; i++) {
ctx->last[i] = off[i];
}
return;
}
void Poly1305Final(Poly1305Ctx *ctx, uint8_t mac[POLY1305_TAGSIZE])
{
uint32_t len = ctx->lastLen;
if (len > 0) {
/**
* For the shorter block, it can be 2^120, 2^112, or any power of two that is
* evenly divisible by 8, all the way down to 2^8
*/
ctx->last[len++] = 1;
/**
* If the block is not 17 bytes long (the last block), pad it with
* zeros. This is meaningless if you are treating the blocks as
* numbers.
*/
while (len < POLY1305_BLOCKSIZE) {
ctx->last[len++] = 0;
}
Poly1305Block(ctx, ctx->last, POLY1305_BLOCKSIZE, 0);
ctx->lastLen = 0;
}
Poly1305Last(ctx, mac);
}
int32_t MODES_CHACHA20POLY1305_Encrypt(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL || len == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = ctx->method->encryptBlock(ctx->key, in, out, len);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
Poly1305Update(&(ctx->polyCtx), out, len);
ctx->cipherTextLen += (uint64_t)len;
return CRYPT_SUCCESS;
}
int32_t MODES_CHACHA20POLY1305_Decrypt(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL || len == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
Poly1305Update(&(ctx->polyCtx), in, len);
ctx->cipherTextLen += (uint64_t)len;
int32_t ret = ctx->method->decryptBlock(ctx->key, in, out, len);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
static void CipherTextPad(MODES_CipherChaChaPolyCtx *ctx)
{
/**
* The ciphertext
* padding2 -- the padding is up to 15 zero bytes, and it brings
* the total length so far to an integral multiple of 16. If the
* length of the ciphertext was already an integral multiple of 16
* bytes, this field is zero-length.
*/
Poly1305Ctx *polyCtx = &(ctx->polyCtx);
uint32_t len = polyCtx->lastLen;
if (len != 0) {
const uint8_t pad2[POLY1305_BLOCKSIZE] = {0};
Poly1305Update(polyCtx, pad2, POLY1305_BLOCKSIZE - len);
}
uint8_t pad[POLY1305_BLOCKSIZE];
/**
* The length of the additional data in octets (as a 64-bit
* little-endian integer).
*/
PUT_UINT64_LE(ctx->aadLen, pad, 0); // The first eight bytes are padded with the length of the AAD.
/**
* The length of the ciphertext in octets (as a 64-bit littleendian
* integer).
*/
PUT_UINT64_LE(ctx->cipherTextLen, pad, 8); // The last 8 bytes are padded the length of the ciphertext.
Poly1305Update(polyCtx, pad, POLY1305_BLOCKSIZE);
}
static int32_t GetTag(MODES_CipherChaChaPolyCtx *ctx, uint8_t *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != POLY1305_TAGSIZE) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_TAGLEN_ERROR);
return CRYPT_MODES_TAGLEN_ERROR;
}
CipherTextPad(ctx);
Poly1305Final(&(ctx->polyCtx), val);
return CRYPT_SUCCESS;
}
static int32_t SetIv(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *iv, uint32_t ivLen)
{
/**
* RFC_7539-2.6
* ChaCha20 as specified here requires a 96-bit nonce.
* So if the provided nonce is only 64-bit, then the first 32
* bits of the nonce will be set to a constant number. This will
* usually be zero, but for protocols with multiple senders it may be
* different for each sender, but should be the same for all
* invocations of the function with the same key by a particular
* sender.
*/
if (iv == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
// 96 bits or 64 bits, that is, 12 bytes or 8 bytes.
if (ivLen != 12 && ivLen != 8) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_IVLEN_ERROR);
return CRYPT_MODES_IVLEN_ERROR;
}
int32_t ret;
uint8_t block[POLY1305_KEYSIZE] = { 0 };
if (ivLen == 8) { // If the length of the IV is 8, 0 data must be padded before.
uint8_t tmpBuff[12] = { 0 };
(void)memcpy_s(tmpBuff + 4, sizeof(tmpBuff) - 4, iv, ivLen); // // 4 bytes 0 data must be padded before.
ret = ctx->method->cipherCtrl(ctx->key, CRYPT_CTRL_SET_IV, tmpBuff, sizeof(tmpBuff));
// Clear sensitive data.
(void)BSL_SAL_CleanseData(tmpBuff, sizeof(tmpBuff));
} else {
ret = ctx->method->cipherCtrl(ctx->key, CRYPT_CTRL_SET_IV, (void *)(uintptr_t)iv, ivLen);
}
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
/**
* RFC_7539-2.6
* The block counter is set to zero
*/
uint8_t initCount[4] = { 0 };
ret = ctx->method->cipherCtrl(ctx->key, CRYPT_CTRL_SET_COUNT, initCount, sizeof(initCount));
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = ctx->method->encryptBlock(ctx->key, block, block, POLY1305_KEYSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
Poly1305SetKey(&(ctx->polyCtx), block);
/**
* RFC_7539-2.8
* the ChaCha20 encryption function is called to encrypt the
* plaintext, using the same key and nonce, and with the initial
* counter set to 1
*/
initCount[0] = 0x01;
ret = ctx->method->cipherCtrl(ctx->key, CRYPT_CTRL_SET_COUNT, initCount, sizeof(initCount)); // 4bytes count
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
// Information that needs to be reset.
ctx->aadLen = 0;
ctx->cipherTextLen = 0;
return ret;
}
// Set the AAD information. The AAD information can be set only once.
static int32_t SetAad(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *aad, uint32_t aadLen)
{
/**
* RFC_7539-2.8
* The AAD
* padding1 -- the padding is up to 15 zero bytes, and it brings
* the total length so far to an integral multiple of 16. If the
* length of the AAD was already an integral multiple of 16 bytes,
* this field is zero-length.
*/
if (ctx->aadLen != 0 || ctx->cipherTextLen != 0) { // aad is set
BSL_ERR_PUSH_ERROR(CRYPT_MODES_AAD_REPEAT_SET_ERROR);
return CRYPT_MODES_AAD_REPEAT_SET_ERROR;
}
if (aadLen == 0) {
return CRYPT_SUCCESS;
}
if (aad == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
const uint8_t pad[16] = { 0 };
ctx->aadLen = aadLen;
Poly1305Update(&(ctx->polyCtx), aad, aadLen);
uint32_t padLen = (16 - aadLen % 16) % 16;
Poly1305Update(&(ctx->polyCtx), pad, padLen);
return CRYPT_SUCCESS;
}
int32_t MODES_CHACHA20POLY1305_SetEncryptKey(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *key, uint32_t len)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return ctx->method->setEncryptKey(ctx->key, key, len);
}
int32_t MODES_CHACHA20POLY1305_SetDecryptKey(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *key, uint32_t len)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return ctx->method->setDecryptKey(ctx->key, key, len);
}
int32_t MODES_CHACHA20POLY1305_Ctrl(MODES_CHACHAPOLY_Ctx *modeCtx, int32_t opt, void *val, uint32_t len)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
switch (opt) {
case CRYPT_CTRL_REINIT_STATUS:
return SetIv(&modeCtx->chachaCtx, val, len);
case CRYPT_CTRL_GET_TAG:
return GetTag(&modeCtx->chachaCtx, val, len);
case CRYPT_CTRL_SET_AAD:
return SetAad(&modeCtx->chachaCtx, val, len);
case CRYPT_CTRL_GET_BLOCKSIZE:
if (val == NULL || len != sizeof(uint32_t)) {
return CRYPT_INVALID_ARG;
}
*(int32_t *)val = 1;
return CRYPT_SUCCESS;
default:
if (modeCtx->chachaCtx.method == NULL ||
modeCtx->chachaCtx.method->cipherCtrl == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TYPE_ERROR);
return CRYPT_MODES_CTRL_TYPE_ERROR;
}
return modeCtx->chachaCtx.method->cipherCtrl(modeCtx->chachaCtx.key, opt, val, len);
}
}
MODES_CHACHAPOLY_Ctx *MODES_CHACHA20POLY1305_NewCtx(int32_t algId)
{
const EAL_SymMethod *method = EAL_GetSymMethod(algId);
if (method == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return NULL;
}
MODES_CHACHAPOLY_Ctx *ctx = BSL_SAL_Calloc(1, sizeof(MODES_CHACHAPOLY_Ctx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return ctx;
}
ctx->algId = algId;
ctx->chachaCtx.key = BSL_SAL_Calloc(1, method->ctxSize);
if (ctx->chachaCtx.key == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
BSL_SAL_Free(ctx);
return NULL;
}
ctx->chachaCtx.method = method;
return ctx;
}
int32_t MODES_CHACHA20POLY1305_InitCtx(MODES_CHACHAPOLY_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen,
const uint8_t *iv, uint32_t ivLen, void *param, bool enc)
{
(void)param;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = enc ? modeCtx->chachaCtx.method->setEncryptKey(modeCtx->chachaCtx.key, key, keyLen) :
modeCtx->chachaCtx.method->setDecryptKey(modeCtx->chachaCtx.key, key, keyLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = SetIv(&modeCtx->chachaCtx, iv, ivLen);
if (ret != CRYPT_SUCCESS) {
modeCtx->chachaCtx.method->cipherDeInitCtx(modeCtx->chachaCtx.key);
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
modeCtx->enc = enc;
return ret;
}
int32_t MODES_CHACHA20POLY1305_Update(MODES_CHACHAPOLY_Ctx *modeCtx, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return MODES_CipherStreamProcess(modeCtx->enc ? MODES_CHACHA20POLY1305_Encrypt : MODES_CHACHA20POLY1305_Decrypt,
&modeCtx->chachaCtx, in, inLen, out, outLen);
}
int32_t MODES_CHACHA20POLY1305_Final(MODES_CHACHAPOLY_Ctx *modeCtx, uint8_t *out, uint32_t *outLen)
{
(void) modeCtx;
(void) out;
(void) outLen;
return CRYPT_EAL_CIPHER_FINAL_WITH_AEAD_ERROR;
}
int32_t MODES_CHACHA20POLY1305_DeInitCtx(MODES_CHACHAPOLY_Ctx *modeCtx)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
modeCtx->chachaCtx.method->cipherDeInitCtx(modeCtx->chachaCtx.key);
BSL_SAL_CleanseData((void *)(&(modeCtx->chachaCtx.polyCtx)), sizeof(Poly1305Ctx));
modeCtx->chachaCtx.aadLen = 0;
modeCtx->chachaCtx.cipherTextLen = 0;
Poly1305CleanRegister();
return CRYPT_SUCCESS;
}
void MODES_CHACHA20POLY1305_FreeCtx(MODES_CHACHAPOLY_Ctx *modeCtx)
{
if (modeCtx == NULL) {
return;
}
modeCtx->chachaCtx.method->cipherDeInitCtx(modeCtx->chachaCtx.key);
BSL_SAL_FREE(modeCtx->chachaCtx.key);
BSL_SAL_ClearFree(modeCtx, sizeof(MODES_CHACHAPOLY_Ctx));
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/modes_chacha20_poly1305.c | C | unknown | 14,601 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CTR
#include "securec.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "crypt_modes_ctr.h"
#include "modes_local.h"
uint32_t MODES_CTR_LastHandle(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
uint32_t left = len;
uint32_t blockSize = ctx->blockSize;
const uint8_t *tmpIn = in;
uint8_t *tmpOut = out;
// buf[0, ctx->offset, blockSize)
// The data from st to blockSize - 1 is the data obtained after the last encryption and is not used up.
while ((ctx->offset != 0) && (left > 0)) {
*(tmpOut++) = ((*(tmpIn++)) ^ (ctx->buf[ctx->offset++]));
--left;
// & (blockSize - 1) is equivalent to mod blockSize.
ctx->offset &= (uint8_t)(blockSize - 1);
}
// Return the calculated length.
return (len - left);
}
void MODES_CTR_RemHandle(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (len == 0) {
return;
}
uint32_t left = len;
uint32_t blockSize = ctx->blockSize;
const uint8_t *tmpIn = in;
uint8_t *tmpOut = out;
// Ensure that the length of IV is 16 when setting it, which will not cause encryption failures.
// To optimize performance, the function does not determine the length of the IV.
(void)ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->iv, ctx->buf, blockSize);
MODE_IncCounter(ctx->iv, ctx->blockSize);
ctx->offset = 0;
while ((left) > 0) {
tmpOut[ctx->offset] = (tmpIn[ctx->offset]) ^ (ctx->buf[ctx->offset]);
--left;
++ctx->offset;
}
}
int32_t MODES_CTR_Crypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
uint32_t offset = MODES_CTR_LastHandle(ctx, in, out, len);
uint32_t left = len - offset;
const uint8_t *tmpIn = in + offset;
uint8_t *tmpOut = out + offset;
uint32_t blockSize = ctx->blockSize;
while (left >= blockSize) {
// Ensure that the length of IV is 16 when setting it, which will not cause encryption failures.
// To optimize performance, the function does not determine the length of the IV.
(void)ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->iv, ctx->buf, blockSize);
MODE_IncCounter(ctx->iv, ctx->blockSize);
DATA64_XOR(tmpIn, ctx->buf, tmpOut, blockSize);
left -= blockSize;
tmpOut += blockSize;
tmpIn += blockSize;
}
MODES_CTR_RemHandle(ctx, tmpIn, tmpOut, left);
return CRYPT_SUCCESS;
}
MODES_CipherCtx *MODES_CTR_NewCtx(int32_t algId)
{
return MODES_CipherNewCtx(algId);
}
int32_t MODES_CTR_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_CipherInitCtx(modeCtx, modeCtx->commonCtx.ciphMeth->setEncryptKey,
modeCtx->commonCtx.ciphCtx, key, keyLen, iv, ivLen, enc);
}
int32_t MODES_CTR_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(MODES_CTR_Crypt, &modeCtx->commonCtx, in, inLen, out, outLen);
}
int32_t MODES_CTR_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
(void) modeCtx;
(void) out;
*outLen = 0;
return CRYPT_SUCCESS;
}
int32_t MODES_CTR_DeInitCtx(MODES_CipherCtx *modeCtx)
{
return MODES_CipherDeInitCtx(modeCtx);
}
int32_t MODES_CTR_Ctrl(MODES_CipherCtx *modeCtx, int32_t cmd, void *val, uint32_t valLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (cmd) {
case CRYPT_CTRL_GET_BLOCKSIZE:
if (val == NULL || valLen != sizeof(uint32_t)) {
return CRYPT_INVALID_ARG;
}
*(int32_t *)val = 1;
return CRYPT_SUCCESS;
default:
return MODES_CipherCtrl(modeCtx, cmd, val, valLen);;
}
}
void MODES_CTR_FreeCtx(MODES_CipherCtx *modeCtx)
{
MODES_CipherFreeCtx(modeCtx);
}
int32_t MODES_CTR_InitCtxEx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, void *param, bool enc)
{
(void)param;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_SM4_CTR:
#ifdef HITLS_CRYPTO_SM4
return SM4_CTR_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_CTR_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
}
int32_t MODES_CTR_UpdateEx(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_AES128_CTR:
case CRYPT_CIPHER_AES192_CTR:
case CRYPT_CIPHER_AES256_CTR:
#ifdef HITLS_CRYPTO_AES
return AES_CTR_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
case CRYPT_CIPHER_SM4_CTR:
#ifdef HITLS_CRYPTO_SM4
return SM4_CTR_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_CTR_Update(modeCtx, in, inLen, out, outLen);
}
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/modes_ctr.c | C | unknown | 6,028 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_ECB
#include "bsl_err_internal.h"
#include "bsl_sal.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "crypt_modes_ecb.h"
#include "modes_local.h"
#include "securec.h"
int32_t MODES_ECB_Crypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
{
// ctx, in, out, these pointer have been judged at the EAL layer and is not judged again here.
if (ctx->ciphCtx == NULL || len == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret;
uint32_t left = len;
const uint8_t *input = in;
uint8_t *output = out;
uint32_t blockSize = ctx->blockSize;
while (left >= blockSize) {
if (enc) {
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, input, output, blockSize);
} else {
ret = ctx->ciphMeth->decryptBlock(ctx->ciphCtx, input, output, blockSize);
}
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
input += blockSize;
output += blockSize;
left -= blockSize;
}
if (left > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_MODE_ERR_INPUT_LEN);
return CRYPT_MODE_ERR_INPUT_LEN;
}
return CRYPT_SUCCESS;
}
int32_t MODES_ECB_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
return MODES_ECB_Crypt(ctx, in, out, len, true);
}
int32_t MODES_ECB_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
return MODES_ECB_Crypt(ctx, in, out, len, false);
}
MODES_CipherCtx *MODES_ECB_NewCtx(int32_t algId)
{
return MODES_CipherNewCtx(algId);
}
int32_t MODES_ECB_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
(void)iv;
(void)ivLen;
int32_t ret;
ret = enc ? modeCtx->commonCtx.ciphMeth->setEncryptKey(modeCtx->commonCtx.ciphCtx, key, keyLen) :
modeCtx->commonCtx.ciphMeth->setDecryptKey(modeCtx->commonCtx.ciphCtx, key, keyLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
modeCtx->enc = enc;
return ret;
}
int32_t MODES_ECB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherUpdate(modeCtx, modeCtx->enc ? MODES_ECB_Encrypt : MODES_ECB_Decrypt,
in, inLen, out, outLen);
}
int32_t MODES_ECB_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherFinal(modeCtx, modeCtx->enc ? MODES_ECB_Encrypt : MODES_ECB_Decrypt, out, outLen);
}
int32_t MODES_ECB_DeinitCtx(MODES_CipherCtx *modeCtx)
{
return MODES_CipherDeInitCtx(modeCtx);
}
int32_t MODES_ECB_Ctrl(MODES_CipherCtx *modeCtx, int32_t cmd, void *val, uint32_t valLen)
{
int ret;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (cmd) {
case CRYPT_CTRL_REINIT_STATUS:
(void)memset_s(modeCtx->data, EAL_MAX_BLOCK_LENGTH, 0, EAL_MAX_BLOCK_LENGTH);
modeCtx->dataLen = 0;
modeCtx->pad = CRYPT_PADDING_NONE;
return CRYPT_SUCCESS;
case CRYPT_CTRL_SET_PADDING:
if (val == NULL || valLen != sizeof(int32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
if (modeCtx->commonCtx.blockSize == 1) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_PADDING_NOT_SUPPORT);
return CRYPT_EAL_PADDING_NOT_SUPPORT;
}
ret = MODES_SetPaddingCheck(*(int32_t *)val);
if (ret != CRYPT_SUCCESS) {
return ret;
}
modeCtx->pad = *(int32_t *)val;
return CRYPT_SUCCESS;
case CRYPT_CTRL_GET_PADDING:
if (val == NULL || valLen != sizeof(int32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
*(int32_t *)val = modeCtx->pad;
return CRYPT_SUCCESS;
case CRYPT_CTRL_GET_BLOCKSIZE:
if (val == NULL || valLen != sizeof(uint32_t)) {
return CRYPT_INVALID_ARG;
}
*(int32_t *)val = modeCtx->commonCtx.ciphMeth->blockSize;
return CRYPT_SUCCESS;
default:
return MODES_CipherCtrl(modeCtx, cmd, val, valLen);
}
}
void MODES_ECB_FreeCtx(MODES_CipherCtx *modeCtx)
{
MODES_CipherFreeCtx(modeCtx);
}
int32_t MODES_ECB_InitCtxEx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, void *param, bool enc)
{
(void)param;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_SM4_ECB:
#ifdef HITLS_CRYPTO_SM4
return SM4_ECB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_ECB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
}
int32_t MODES_ECB_UpdateEx(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_AES128_ECB:
case CRYPT_CIPHER_AES192_ECB:
case CRYPT_CIPHER_AES256_ECB:
#ifdef HITLS_CRYPTO_AES
return AES_ECB_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
case CRYPT_CIPHER_SM4_ECB:
#ifdef HITLS_CRYPTO_SM4
return SM4_ECB_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_ECB_Update(modeCtx, in, inLen, out, outLen);
}
}
int32_t MODES_ECB_FinalEx(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_AES128_ECB:
case CRYPT_CIPHER_AES192_ECB:
case CRYPT_CIPHER_AES256_ECB:
#ifdef HITLS_CRYPTO_AES
return AES_ECB_Final(modeCtx, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
case CRYPT_CIPHER_SM4_ECB:
#ifdef HITLS_CRYPTO_SM4
return SM4_ECB_Final(modeCtx, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_ECB_Final(modeCtx, out, outLen);
}
}
#endif // end HITLS_CRYPTO_ECB
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/modes_ecb.c | C | unknown | 7,331 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_GCM
#include <stdint.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "crypt_modes_gcm.h"
#include "modes_local.h"
#include "crypt_modes.h"
int32_t MODES_GCM_SetKey(MODES_CipherGCMCtx *ctx, const uint8_t *key, uint32_t len)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = ctx->ciphMeth->setEncryptKey(ctx->ciphCtx, key, len);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
return MODES_GCM_InitHashTable(ctx);
}
int32_t MODES_GCM_InitHashTable(MODES_CipherGCMCtx *ctx)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
uint8_t gcmKey[GCM_BLOCKSIZE] = { 0 };
int32_t ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, gcmKey, gcmKey, GCM_BLOCKSIZE);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
GcmTableGen4bit(gcmKey, ctx->hTable);
ctx->tagLen = GCM_BLOCKSIZE;
BSL_SAL_CleanseData(gcmKey, sizeof(gcmKey));
return CRYPT_SUCCESS;
}
// Update the number of usage times.
static int32_t CheckUseCnt(const MODES_CipherGCMCtx *ctx)
{
// 128, 120, 112, 104, or 96 that is 12 byte - 16 byte
if (ctx->cryptCnt == GCM_MAX_INVOCATIONS_TIMES) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_KEYUSE_TOOMANY_TIME);
return CRYPT_MODES_KEYUSE_TOOMANY_TIME;
}
return CRYPT_SUCCESS;
}
/**
* NIST_800-38D-5.2
* 1 ≤ len(IV) ≤ 2^64 - 1 (bit)
* It is currently restricted to no more than 2^32 - 1 bytes
*/
int32_t MODES_GCM_SetIv(MODES_CipherGCMCtx *ctx, const uint8_t *iv, uint32_t ivLen)
{
if (iv == NULL || ivLen == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = CheckUseCnt(ctx); // Check the number of usage times.
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
uint32_t i;
uint64_t len = (uint64_t)ivLen;
// when ivLen == 0, do reinit, no need to refersh iv
if (len == 12) { // len(IV ) = 96bit = 12byte
const uint8_t ivPad[4] = {0x00, 0x00, 0x00, 0x01};
/* Y0 = IV || 0^31 || 1 if len(IV ) = 96 = 12byte */
(void)memcpy_s(ctx->iv, GCM_BLOCKSIZE, iv, 12);
(void)memcpy_s(ctx->iv + 12, GCM_BLOCKSIZE - 12, ivPad, sizeof(ivPad)); // pad last 4bit(base = 12)
} else {
/* Y0 = GHASH(H, {}, IV ) otherwise */
(void)memset_s(ctx->iv, GCM_BLOCKSIZE, 0, GCM_BLOCKSIZE);
const uint8_t *off = iv;
uint32_t blockLen = ivLen & GCM_BLOCK_MASK;
uint32_t lastLen = ivLen - blockLen;
uint8_t tmp[GCM_BLOCKSIZE] = {0};
if (blockLen > 0) {
GcmHashMultiBlock(ctx->iv, ctx->hTable, off, blockLen);
off += blockLen;
}
if (lastLen > 0) {
for (i = 0; i < lastLen; i++) {
tmp[i] = off[i];
}
GcmHashMultiBlock(ctx->iv, ctx->hTable, tmp, GCM_BLOCKSIZE);
}
len = (uint64_t)ivLen << 3; // bitLen = byteLen << 3
(void)BSL_SAL_CleanseData(tmp, GCM_BLOCKSIZE);
Uint64ToBeBytes(len, tmp + 8); // The last 8 bytes store the length of the IV.
GcmHashMultiBlock(ctx->iv, ctx->hTable, tmp, GCM_BLOCKSIZE);
}
/**
* NIST_800-38D-7.1
* GCTR(J0)
*/
ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->iv, ctx->ek0, GCM_BLOCKSIZE);
/**
* NIST_800-38D-7.1
* INC32
* the 32-bit incrementing function is applied to the pre-counter block
* to produce the initial counter block for an invocation of the GCTR
* function on the plaintext
*/
uint32_t ctr = GET_UINT32_BE(ctx->iv, 12); // Offset of 12 bytes. Use the last four bytes.
ctr++;
PUT_UINT32_BE(ctr, ctx->iv, 12); // Writeback of offset 12 bytes
// Reset information.
(void)memset_s(ctx->ghash, GCM_BLOCKSIZE, 0, GCM_BLOCKSIZE);
ctx->aadLen = 0;
(void)memset_s(ctx->last, GCM_BLOCKSIZE, 0, GCM_BLOCKSIZE);
ctx->lastLen = 0;
ctx->plaintextLen = 0;
(void)memset_s(ctx->remCt, GCM_BLOCKSIZE, 0, GCM_BLOCKSIZE);
// Clear sensitive information.
BSL_SAL_CleanseData(&ctr, sizeof(uint32_t));
return CRYPT_SUCCESS;
}
/**
* NIST_800-38D-5.2
* len(AAD) ≤ 2^64 - 1 (bit)
* Currently, it is restricted to no more than 2^32 - 1 bytes.
*/
static int32_t SetAad(MODES_CipherGCMCtx *ctx, const uint8_t *aad, uint32_t aadLen)
{
if (aad == NULL && aadLen != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
const uint8_t *off = aad;
uint32_t i;
if (ctx->aadLen != 0 || ctx->plaintextLen != 0) { // aad is set
BSL_ERR_PUSH_ERROR(CRYPT_MODES_AAD_REPEAT_SET_ERROR);
return CRYPT_MODES_AAD_REPEAT_SET_ERROR;
}
uint32_t blockLen = aadLen & GCM_BLOCK_MASK;
uint32_t lastLen = aadLen - blockLen;
if (blockLen > 0) {
GcmHashMultiBlock(ctx->ghash, ctx->hTable, off, blockLen);
off += blockLen;
}
if (lastLen > 0) {
uint8_t temp[GCM_BLOCKSIZE] = {0};
for (i = 0; i < lastLen; i++) {
temp[i] = off[i];
}
GcmHashMultiBlock(ctx->ghash, ctx->hTable, temp, GCM_BLOCKSIZE);
}
ctx->aadLen = aadLen;
return CRYPT_SUCCESS;
}
// Overflow occurs when the encryption length is determined and the encrypted length information is updated.
int32_t CryptLenCheckAndRefresh(MODES_CipherGCMCtx *ctx, uint32_t len)
{
// The length of len is only 32 bits. This calculation does not cause overflow.
uint64_t plaintextLen = ctx->plaintextLen + len;
if (plaintextLen > GCM_MAX_COMBINED_LENGTH) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CRYPTLEN_OVERFLOW);
return CRYPT_MODES_CRYPTLEN_OVERFLOW;
}
ctx->plaintextLen = plaintextLen;
return CRYPT_SUCCESS;
}
static void GcmXorInEncrypt(XorCryptData *data, uint32_t len)
{
uint32_t i;
for (i = 0; i < len; i++) {
data->out[i] = data->in[i] ^ data->ctr[i];
data->tag[i] = data->out[i];
}
}
static void GcmXorInDecrypt(XorCryptData *data, uint32_t len)
{
uint32_t i;
for (i = 0; i < len; i++) {
data->tag[i] = data->in[i];
data->out[i] = data->in[i] ^ data->ctr[i];
}
}
// Process the remaining data in the last update.
uint32_t MODES_GCM_LastHandle(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
{
uint32_t lastLen = 0;
if (ctx->lastLen > 0) {
XorCryptData data;
lastLen = (ctx->lastLen < len) ? ctx->lastLen : len;
data.in = in;
data.out = out;
data.ctr = &(ctx->last[GCM_BLOCKSIZE - ctx->lastLen]);
data.tag = &(ctx->remCt[GCM_BLOCKSIZE - ctx->lastLen]);
if (enc) { // ctx->lastLen must be smaller than the GCM_BLOCKSIZE
GcmXorInEncrypt(&data, lastLen);
} else {
GcmXorInDecrypt(&data, lastLen);
}
// Refresh the remaining length.
ctx->lastLen -= lastLen;
if (ctx->lastLen == 0) {
GcmHashMultiBlock(ctx->ghash, ctx->hTable, ctx->remCt, GCM_BLOCKSIZE);
}
}
return lastLen;
}
static void GcmMultiBlockCrypt(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
{
uint32_t blockLen = len;
const uint8_t *dataIn = in;
uint8_t *dataOut = out;
// count information, last 32 bits of the IV, with an offset of 12 bytes (16-4 = 12)
uint32_t ctr = GET_UINT32_BE(ctx->iv, 12);
if (enc == false) {
GcmHashMultiBlock(ctx->ghash, ctx->hTable, in, len);
}
while (blockLen > 0) {
ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->iv, ctx->last, GCM_BLOCKSIZE);
DATA64_XOR(dataIn, ctx->last, dataOut, GCM_BLOCKSIZE);
/**
* NIST_800-38D-7.1
* INC32
*/
ctr++;
PUT_UINT32_BE(ctr, ctx->iv, 12); // Offset of 12 bytes. Use the last four bytes.
// Refresh the remaining length.
blockLen -= GCM_BLOCKSIZE;
// offset
dataIn += GCM_BLOCKSIZE;
dataOut += GCM_BLOCKSIZE;
}
if (enc) {
GcmHashMultiBlock(ctx->ghash, ctx->hTable, out, len);
}
// Clear sensitive information.
BSL_SAL_CleanseData(&ctr, sizeof(uint32_t));
}
// enc: true: the encryption operation, false: the decryption operation
static int32_t MODES_GCM_Crypt(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc)
{
if (ctx == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != 0 && in == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = CryptLenCheckAndRefresh(ctx, len);
if (ret != CRYPT_SUCCESS) {
return ret;
}
uint32_t lastLen = MODES_GCM_LastHandle(ctx, in, out, len, enc);
// Data processing is complete. Exit.
if (lastLen == len) {
return CRYPT_SUCCESS;
}
XorCryptData data;
data.in = in + lastLen;
data.out = out + lastLen;
data.ctr = ctx->last;
data.tag = ctx->remCt;
uint32_t multiBlockLen = (len - lastLen) & GCM_BLOCK_MASK;
if (multiBlockLen > 0) {
GcmMultiBlockCrypt(ctx, data.in, data.out, multiBlockLen, enc);
data.in += multiBlockLen;
data.out += multiBlockLen;
}
uint32_t remLen = len - lastLen - multiBlockLen;
if (remLen > 0) {
// count information, last 32 bits of the IV, with an offset of 12 bytes (16-4 = 12)
uint32_t ctr = GET_UINT32_BE(ctx->iv, 12);
(void)ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->iv, ctx->last, GCM_BLOCKSIZE);
if (enc) {
GcmXorInEncrypt(&data, remLen);
} else {
GcmXorInDecrypt(&data, remLen);
}
/**
* NIST_800-38D-7.1
* INC32
*/
ctr++;
PUT_UINT32_BE(ctr, ctx->iv, 12); // Offset of 12 bytes. Use the last four bytes.
// Clear sensitive information.
BSL_SAL_CleanseData(&ctr, sizeof(uint32_t));
}
ctx->lastLen = (remLen > 0) ? (GCM_BLOCKSIZE - remLen) : 0;
return CRYPT_SUCCESS;
}
static void GcmPad(MODES_CipherGCMCtx *ctx)
{
// S = GHASHH (A || 0v || C || 0u || [len(A)]64 || [len(C)]64).
if (ctx->lastLen != 0) {
uint32_t offset = GCM_BLOCKSIZE - ctx->lastLen;
(void)memset_s(ctx->remCt + offset, GCM_BLOCKSIZE - offset, 0, ctx->lastLen);
GcmHashMultiBlock(ctx->ghash, ctx->hTable, ctx->remCt, GCM_BLOCKSIZE);
}
uint64_t aadLen = (uint64_t)(ctx->aadLen) << 3; // bitLen = byteLen << 3
uint64_t plaintextLen = ctx->plaintextLen << 3; // bitLen = byteLen << 3
uint8_t padBuf[GCM_BLOCKSIZE];
Uint64ToBeBytes(aadLen, padBuf);
Uint64ToBeBytes(plaintextLen, padBuf + 8); // The last 64 bits (8 bytes) is the length of the ciphertext.
GcmHashMultiBlock(ctx->ghash, ctx->hTable, padBuf, GCM_BLOCKSIZE);
}
static int32_t SetTagLen(MODES_CipherGCMCtx *ctx, const uint8_t *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != sizeof(uint32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TAGLEN_ERROR);
return CRYPT_MODES_CTRL_TAGLEN_ERROR;
}
/**
* NIST_800-38D-5.2.1.2
* The bit length of the tag, denoted t, is a security parameter, as discussed in Appendix B.
* In general, t may be any one of the following five values: 128, 120, 112, 104, or 96. For certain
* applications, t may be 64 or 32; guidance for the use of these two tag lengths, including
* requirements on the length of the input data and the lifetime of the ciphCtx in these cases,
* is given in Appendix C
*/
uint32_t tagLen = *((const uint32_t *)val);
// 32bit is 4 bytes, 64bit is 8 bytes, 128, 120, 112, 104, or 96 is 12byte - 16byte
if (tagLen == 4 || tagLen == 8 || (tagLen >= 12 && tagLen <= 16)) {
ctx->tagLen = (uint8_t)tagLen;
return CRYPT_SUCCESS;
}
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TAGLEN_ERROR);
return CRYPT_MODES_CTRL_TAGLEN_ERROR;
}
static int32_t GetTag(MODES_CipherGCMCtx *ctx, uint8_t *val, uint32_t len)
{
if (val == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (len != ctx->tagLen) {
BSL_ERR_PUSH_ERROR(CRYPT_MODES_TAGLEN_ERROR);
return CRYPT_MODES_TAGLEN_ERROR;
}
ctx->cryptCnt++; // The encryption/decryption process ends. Key usage times + 1
GcmPad(ctx);
uint32_t i;
for (i = 0; i < len; i++) {
val[i] = ctx->ghash[i] ^ ctx->ek0[i];
}
return CRYPT_SUCCESS;
}
int32_t MODES_GCM_Encrypt(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
return MODES_GCM_Crypt(ctx, in, out, len, true);
}
int32_t MODES_GCM_Decrypt(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
return MODES_GCM_Crypt(ctx, in, out, len, false);
}
int32_t MODES_GCM_Ctrl(MODES_GCM_Ctx *modeCtx, int32_t opt, void *val, uint32_t len)
{
if (modeCtx == NULL) {
return CRYPT_NULL_INPUT;
}
switch (opt) {
case CRYPT_CTRL_SET_IV:
case CRYPT_CTRL_REINIT_STATUS:
return MODES_GCM_SetIv(&modeCtx->gcmCtx, val, len);
case CRYPT_CTRL_SET_TAGLEN:
return SetTagLen(&modeCtx->gcmCtx, val, len);
case CRYPT_CTRL_SET_AAD:
return SetAad(&modeCtx->gcmCtx, val, len);
case CRYPT_CTRL_GET_TAG:
return GetTag(&modeCtx->gcmCtx, val, len);
case CRYPT_CTRL_GET_BLOCKSIZE:
if (val == NULL || len != sizeof(uint32_t)) {
return CRYPT_INVALID_ARG;
}
*(int32_t *)val = 1;
return CRYPT_SUCCESS;
default:
BSL_ERR_PUSH_ERROR(CRYPT_MODES_CTRL_TYPE_ERROR);
return CRYPT_MODES_CTRL_TYPE_ERROR;
}
}
MODES_GCM_Ctx *MODES_GCM_NewCtx(int32_t algId)
{
const EAL_SymMethod *method = EAL_GetSymMethod(algId);
if (method == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return NULL;
}
MODES_GCM_Ctx *ctx = BSL_SAL_Calloc(1, sizeof(MODES_GCM_Ctx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return ctx;
}
ctx->algId = algId;
ctx->gcmCtx.ciphCtx = BSL_SAL_Calloc(1, method->ctxSize);
if (ctx->gcmCtx.ciphCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
BSL_SAL_Free(ctx);
return NULL;
}
ctx->gcmCtx.ciphMeth = method;
return ctx;
}
int32_t MODES_GCM_InitCtx(MODES_GCM_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = MODES_GCM_SetKey(&modeCtx->gcmCtx, key, keyLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
ret = MODES_GCM_SetIv(&modeCtx->gcmCtx, iv, ivLen);
if (ret != CRYPT_SUCCESS) {
(void)MODES_GCM_DeInitCtx(modeCtx);
return ret;
}
modeCtx->enc = enc;
return ret;
}
int32_t MODES_GCM_Update(MODES_GCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(modeCtx->enc ? MODES_GCM_Encrypt : MODES_GCM_Decrypt, &modeCtx->gcmCtx,
in, inLen, out, outLen);
}
int32_t MODES_GCM_Final(MODES_GCM_Ctx *modeCtx, uint8_t *out, uint32_t *outLen)
{
(void) modeCtx;
(void) out;
(void) outLen;
return CRYPT_EAL_CIPHER_FINAL_WITH_AEAD_ERROR;
}
int32_t MODES_GCM_DeInitCtx(MODES_GCM_Ctx *modeCtx)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t algId = modeCtx->algId;
void *ciphCtx = modeCtx->gcmCtx.ciphCtx;
const EAL_SymMethod *ciphMeth = modeCtx->gcmCtx.ciphMeth;
modeCtx->gcmCtx.ciphMeth->cipherDeInitCtx(ciphCtx);
BSL_SAL_CleanseData((void *)(&(modeCtx->gcmCtx)), sizeof(MODES_CipherGCMCtx));
modeCtx->gcmCtx.ciphCtx = ciphCtx;
modeCtx->gcmCtx.ciphMeth = ciphMeth;
modeCtx->algId = algId;
return CRYPT_SUCCESS;
}
void MODES_GCM_FreeCtx(MODES_GCM_Ctx *modeCtx)
{
if (modeCtx == NULL) {
return;
}
(void)BSL_SAL_ClearFree(modeCtx->gcmCtx.ciphCtx, modeCtx->gcmCtx.ciphMeth->ctxSize);
(void)BSL_SAL_CleanseData(modeCtx, sizeof(MODES_GCM_Ctx));
BSL_SAL_Free(modeCtx);
}
int32_t MODES_GCM_InitCtxEx(MODES_GCM_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, void *param, bool enc)
{
(void)param;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_SM4_GCM:
#ifdef HITLS_CRYPTO_SM4
return SM4_GCM_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_GCM_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
}
int32_t MODES_GCM_UpdateEx(MODES_GCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_AES128_GCM:
case CRYPT_CIPHER_AES192_GCM:
case CRYPT_CIPHER_AES256_GCM:
#ifdef HITLS_CRYPTO_AES
return AES_GCM_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
case CRYPT_CIPHER_SM4_GCM:
#ifdef HITLS_CRYPTO_SM4
return SM4_GCM_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_GCM_Update(modeCtx, in, inLen, out, outLen);
}
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/modes_gcm.c | C | unknown | 18,606 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef MODES_LOCAL_H
#define MODES_LOCAL_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_MODES
#include <stdint.h>
#include <stdbool.h>
#include "crypt_local_types.h"
#include "crypt_modes_xts.h"
#include "crypt_modes_cbc.h"
#include "crypt_modes_ccm.h"
#include "crypt_modes_cfb.h"
#include "crypt_modes_chacha20poly1305.h"
#include "crypt_modes_ctr.h"
#include "crypt_modes_ecb.h"
#include "crypt_modes_gcm.h"
#include "crypt_modes_ofb.h"
#include "crypt_modes.h"
#include "eal_cipher_local.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
#define UPDATE_VALUES(l, i, o, len) \
do { \
(l) -= (len); \
(i) += (len); \
(o) += (len); \
} while (false)
MODES_CipherCtx *MODES_CipherNewCtx(int32_t algId);
int32_t MODES_CipherInitCommonCtx(MODES_CipherCommonCtx *modeCtx, void *setSymKey, void *keyCtx,
const uint8_t *key, uint32_t keyLen, const uint8_t *iv, uint32_t ivLen);
int32_t MODES_CipherInitCtx(MODES_CipherCtx *ctx, void *setSymKey, void *keyCtx, const uint8_t *key,
uint32_t keyLen, const uint8_t *iv, uint32_t ivLen, bool enc);
int32_t MODE_CheckUpdateParam(uint8_t blockSize, uint32_t cacheLen, uint32_t inLen, uint32_t *outLen);
/* Block cipher processing */
int32_t MODES_CipherUpdate(MODES_CipherCtx *modeCtx, void *blockUpdate, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen);
int32_t MODES_BlockPadding(int32_t algId, int32_t padding, uint8_t blockSize, uint8_t *data, uint8_t *dataLen);
int32_t MODES_BlockUnPadding(int32_t padding, const uint8_t *pad, uint32_t padLen, uint32_t *dataLen);
/* Block cipher processing */
int32_t MODES_CipherFinal(MODES_CipherCtx *modeCtx, void *blockUpdate, uint8_t *out, uint32_t *outLen);
int32_t MODES_CipherDeInitCtx(MODES_CipherCtx *modeCtx);
void MODES_CipherFreeCtx(MODES_CipherCtx *modeCtx);
int32_t MODES_CipherCtrl(MODES_CipherCtx *ctx, int32_t opt, void *val, uint32_t len);
int32_t MODES_CipherStreamProcess(void *processFuncs, void *ctx, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen);
static inline void MODE_IncCounter(uint8_t *counter, uint32_t counterLen)
{
uint32_t i = counterLen;
uint16_t carry = 1;
while (i > 0) {
i--;
carry += counter[i];
counter[i] = carry & (0xFFu);
carry >>= 8; // Take the upper 8 bits.
}
}
int32_t MODES_SetEncryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len);
int32_t MODES_SetDecryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len);
int32_t MODES_SetPaddingCheck(int32_t pad);
#ifdef HITLS_CRYPTO_SM4
int32_t MODES_SM4_SetEncryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len);
int32_t MODES_SM4_SetDecryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len);
#endif
// cfb
#ifdef HITLS_CRYPTO_CFB
int32_t MODES_CFB_Encrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_CFB_Decrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
// ctr
#ifdef HITLS_CRYPTO_CTR
uint32_t MODES_CTR_LastHandle(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
void MODES_CTR_RemHandle(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
// gcm
#ifdef HITLS_CRYPTO_GCM
void GcmTableGen4bit(uint8_t key[GCM_BLOCKSIZE], MODES_GCM_GF128 hTable[16]);
void GcmHashMultiBlock(uint8_t t[GCM_BLOCKSIZE], const MODES_GCM_GF128 hTable[16], const uint8_t *in, uint32_t inLen);
uint32_t MODES_GCM_LastHandle(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc);
int32_t MODES_GCM_SetIv(MODES_CipherGCMCtx *ctx, const uint8_t *iv, uint32_t ivLen);
int32_t CryptLenCheckAndRefresh(MODES_CipherGCMCtx *ctx, uint32_t len);
#endif
// xts
#ifdef HITLS_CRYPTO_XTS
int32_t MODES_XTS_CheckPara(const uint8_t *key, uint32_t len, const uint8_t *iv);
int32_t MODES_XTS_SetIv(MODES_CipherXTSCtx *ctx, const uint8_t *val, uint32_t len);
int32_t MODES_XTS_SetEncryptKey(MODES_CipherXTSCtx *ctx, const uint8_t *key, uint32_t len);
int32_t MODES_XTS_SetDecryptKey(MODES_CipherXTSCtx *ctx, const uint8_t *key, uint32_t len);
#endif
#ifdef HITLS_CRYPTO_CBC
int32_t AES_CBC_EncryptBlock(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t AES_CBC_DecryptBlock(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_CBC_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_CBC_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODE_SM4_CBC_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODE_SM4_CBC_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
#ifdef HITLS_CRYPTO_CCM
int32_t MODES_CCM_Encrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_CCM_Decrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_AES_CCM_Encrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_AES_CCM_Decrypt(MODES_CipherCCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
#ifdef HITLS_CRYPTO_CFB
int32_t MODES_CFB_BitCrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len, bool enc);
int32_t MODE_AES_CFB_Decrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODE_SM4_CFB_Encrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODE_SM4_CFB_Decrypt(MODES_CipherCFBCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
int32_t MODES_CHACHA20POLY1305_Encrypt(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_CHACHA20POLY1305_Decrypt(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_CHACHA20POLY1305_SetEncryptKey(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *key, uint32_t len);
int32_t MODES_CHACHA20POLY1305_SetDecryptKey(MODES_CipherChaChaPolyCtx *ctx, const uint8_t *key, uint32_t len);
#endif
#ifdef HITLS_CRYPTO_CTR
int32_t MODES_CTR_Crypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t AES_CTR_EncryptBlock(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODE_SM4_CTR_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
#ifdef HITLS_CRYPTO_ECB
int32_t MODES_ECB_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_ECB_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t AES_ECB_EncryptBlock(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t AES_ECB_DecryptBlock(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODE_SM4_ECB_Encrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODE_SM4_ECB_Decrypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
#ifdef HITLS_CRYPTO_GCM
int32_t MODES_GCM_Encrypt(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_GCM_Decrypt(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t AES_GCM_EncryptBlock(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t AES_GCM_DecryptBlock(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_SM4_GCM_DecryptBlock(MODES_CipherGCMCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
#ifdef HITLS_CRYPTO_OFB
int32_t MODES_OFB_Crypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
#ifdef HITLS_CRYPTO_XTS
int32_t MODES_XTS_Encrypt(MODES_CipherXTSCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_XTS_Decrypt(MODES_CipherXTSCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_AES_XTS_Encrypt(MODES_CipherXTSCtx *xtsCtx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_AES_XTS_Decrypt(MODES_CipherXTSCtx *xtsCtx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_SM4_XTS_Encrypt(MODES_CipherXTSCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
int32_t MODES_SM4_XTS_Decrypt(MODES_CipherXTSCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len);
#endif
#ifdef __cplusplus
}
#endif // __cplusplus
#endif
#endif
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/modes_local.h | C | unknown | 9,184 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_OFB
#include "securec.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_errno.h"
#include "modes_local.h"
#include "crypt_modes_ofb.h"
int32_t MODES_OFB_Crypt(MODES_CipherCommonCtx *ctx, const uint8_t *in, uint8_t *out, uint32_t len)
{
if (ctx == NULL || in == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret;
const uint8_t *input = in;
uint32_t blockSize = ctx->blockSize;
uint32_t left = len;
uint8_t *output = out;
uint32_t i;
// If the remaining encrypted iv is not used up last time, use that part to perform XOR.
while (left > 0 && ctx->offset > 0) {
*(output++) = ctx->iv[ctx->offset] ^ *(input++);
left--;
ctx->offset = (ctx->offset + 1) % blockSize;
}
while (left > 0) {
// Encrypt the IV.
ret = ctx->ciphMeth->encryptBlock(ctx->ciphCtx, ctx->iv, ctx->iv, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
if (left >= blockSize) {
DATA32_XOR(input, ctx->iv, output, blockSize);
UPDATE_VALUES(left, input, output, blockSize);
} else {
for (i = 0; i < left; i++) {
output[i] = input[i] ^ ctx->iv[i];
}
ctx->offset = (uint8_t)left;
left = 0;
}
}
return CRYPT_SUCCESS;
}
MODES_CipherCtx *MODES_OFB_NewCtx(int32_t algId)
{
return MODES_CipherNewCtx(algId);
}
int32_t MODES_OFB_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_CipherInitCtx(modeCtx, modeCtx->commonCtx.ciphMeth->setEncryptKey,
modeCtx->commonCtx.ciphCtx, key, keyLen, iv, ivLen, enc);
}
int32_t MODES_OFB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CipherStreamProcess(MODES_OFB_Crypt, &modeCtx->commonCtx,
in, inLen, out, outLen);
}
int32_t MODES_OFB_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
(void) modeCtx;
(void) out;
*outLen = 0;
return CRYPT_SUCCESS;
}
int32_t MODES_OFB_DeInitCtx(MODES_CipherCtx *modeCtx)
{
return MODES_CipherDeInitCtx(modeCtx);
}
int32_t MODES_OFB_Ctrl(MODES_CipherCtx *modeCtx, int32_t cmd, void *val, uint32_t valLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (cmd) {
case CRYPT_CTRL_GET_BLOCKSIZE:
if (val == NULL || valLen != sizeof(uint32_t)) {
return CRYPT_INVALID_ARG;
}
*(int32_t *)val = 1;
return CRYPT_SUCCESS;
default:
return MODES_CipherCtrl(modeCtx, cmd, val, valLen);;
}
}
void MODES_OFB_FreeCtx(MODES_CipherCtx *modeCtx)
{
MODES_CipherFreeCtx(modeCtx);
}
int32_t MODES_OFB_InitCtxEx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, void *param, bool enc)
{
(void) param;
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_SM4_OFB:
#ifdef HITLS_CRYPTO_SM4
return SM4_OFB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_OFB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
}
int32_t MODES_OFB_UpdateEx(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
if (modeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (modeCtx->algId) {
case CRYPT_CIPHER_SM4_OFB:
#ifdef HITLS_CRYPTO_SM4
return SM4_OFB_Update(modeCtx, in, inLen, out, outLen);
#else
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
default:
return MODES_OFB_Update(modeCtx, in, inLen, out, outLen);
}
}
#endif // HITLS_CRYPTO_OFB | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/modes_ofb.c | C | unknown | 4,731 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_CBC)
#include "crypt_modes_cbc.h"
#include "modes_local.h"
int32_t AES_CBC_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CBC_Update(modeCtx, in, inLen, out, outLen);
}
int32_t AES_CBC_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
return MODES_CBC_Final(modeCtx, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/noasm_aes_cbc.c | C | unknown | 1,007 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_CCM)
#include "modes_local.h"
#include "crypt_modes_ccm.h"
int32_t AES_CCM_Update(MODES_CCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CCM_Update(modeCtx, in, inLen, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/noasm_aes_ccm.c | C | unknown | 870 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_CFB)
#include "crypt_modes_cfb.h"
int32_t AES_CFB_Update(MODES_CFB_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CFB_Update(modeCtx, in, inLen, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/noasm_aes_cfb.c | C | unknown | 845 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_CTR)
#include "crypt_modes_ctr.h"
#include "modes_local.h"
int32_t AES_CTR_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CTR_Update(modeCtx, in, inLen, out, outLen);
}
#endif
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/noasm_aes_ctr.c | C | unknown | 873 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_ECB)
#include "crypt_modes_ecb.h"
#include "modes_local.h"
int32_t AES_ECB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_ECB_Update(modeCtx, in, inLen, out, outLen);
}
int32_t AES_ECB_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
return MODES_ECB_Final(modeCtx, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/noasm_aes_ecb.c | C | unknown | 1,041 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_GCM)
#include "crypt_modes_gcm.h"
int32_t AES_GCM_Update(MODES_GCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_GCM_Update(modeCtx, in, inLen, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/noasm_aes_gcm.c | C | unknown | 845 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_AES) && defined(HITLS_CRYPTO_XTS)
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "crypt_aes.h"
#include "crypt_modes_xts.h"
#include "modes_local.h"
int32_t AES_XTS_Update(MODES_XTS_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_XTS_Update(modeCtx, in, inLen, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/noasm_aes_xts.c | C | unknown | 950 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_GCM
#include "bsl_sal.h"
#include "crypt_utils.h"
#include "modes_local.h"
/* table[i] = (P^4)*i, P = 0x4000000000000000, i = 0...16 */
static const uint64_t TABLE_P4_BITS[16] = {
0x0000000000000000, 0x1c20000000000000, 0x3840000000000000, 0x2460000000000000,
0x7080000000000000, 0x6ca0000000000000, 0x48c0000000000000, 0x54e0000000000000,
0xe100000000000000, 0xfd20000000000000, 0xd940000000000000, 0xc560000000000000,
0x9180000000000000, 0x8da0000000000000, 0xa9c0000000000000, 0xb5e0000000000000
};
// Calculate n*H, n is in 0 .... 16
void GcmTableGen4bit(uint8_t key[GCM_BLOCKSIZE], MODES_GCM_GF128 hTable[16])
{
uint32_t i;
uint32_t j;
const uint64_t r = 0xE100000000000000;
hTable[0].h = 0;
hTable[0].l = 0;
// The intermediate term of the table (16 / 2 = = 8) is H itself.
hTable[8].h = Uint64FromBeBytes(key);
// The intermediate term of the table (16 / 2 = = 8) is H itself.
hTable[8].l = Uint64FromBeBytes(key + sizeof(uint64_t));
for (i = 4; i > 0; i >>= 1) { // 4-bit table, the value of the 2^n item is calculated first.
// cyclically shift to right by 1bit. The upper 1 bit of h is combined with the lower 63 bits of l.
hTable[i].l = (hTable[ i * 2].h << 63) | (hTable[ i * 2].l >> 1);
hTable[i].h = (hTable[ i * 2].h >> 1) ^ ((hTable[ i * 2].l & 1) * r); // the value of the 2^n item
}
for (i = 1; i < 16; i <<= 1) {
for (j = 1; j < i; j++) {
hTable[i + j].h = hTable[i].h ^ hTable[j].h;
hTable[i + j].l = hTable[i].l ^ hTable[j].l;
}
}
}
// Calculate t = t * H
void GcmHashMultiBlock(uint8_t t[GCM_BLOCKSIZE], const MODES_GCM_GF128 hTable[16], const uint8_t *in, uint32_t inLen)
{
MODES_GCM_GF128 x;
uint8_t r;
uint8_t h, l, tag; // Ciphertext information, digest information, and non-sensitive information.
const uint8_t *tempIn = in;
for (uint32_t i = 0; i < inLen; i += GCM_BLOCKSIZE) {
uint8_t cnt = GCM_BLOCKSIZE - 1;
x.h = 0;
x.l = 0;
while (1) {
tag = t[cnt] ^ tempIn[cnt];
l = tag & 0xf;
h = (tag >> 4) & 0xf;
x.h ^= hTable[l].h;
x.l ^= hTable[l].l;
r = (x.l & 0xf);
// Cyclically shift to right by 4 bits. The upper 4 bits of h is combined with the lower 60 bits of l.
x.l = (x.h << 60) | (x.l >> 4);
x.h = (x.h >> 4); // Cyclically shift to right by 4 bits.
x.h ^= TABLE_P4_BITS[r];
x.h ^= hTable[h].h;
x.l ^= hTable[h].l;
if (cnt == 0) {
break;
}
cnt--;
r = (x.l & 0xf);
// Cyclically shift to right by 4 bits. The upper 4 bits of h is combined with the lower 60 bits of l.
x.l = (x.h << 60) | (x.l >> 4);
x.h = (x.h >> 4); // Cyclically shift to right by 4 bits.
x.h ^= TABLE_P4_BITS[r];
}
tempIn += GCM_BLOCKSIZE;
Uint64ToBeBytes(x.h, t);
Uint64ToBeBytes(x.l, t + 8);
}
// Clear sensitive information.
BSL_SAL_CleanseData(&x, sizeof(MODES_GCM_GF128));
BSL_SAL_CleanseData(&r, sizeof(uint8_t));
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/noasm_ghash.c | C | unknown | 3,822 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
#include "bsl_sal.h"
#include "crypt_utils.h"
#include "poly1305_core.h"
// Information required by initializing the assembly,
// for example, ctx->table. However, the C language does not calculate the table.
void Poly1305InitForAsm(Poly1305Ctx *ctx)
{
(void)ctx;
return;
}
// Operation for blocks. The return value is the length of the remaining unprocessed data.
uint32_t Poly1305Block(Poly1305Ctx *ctx, const uint8_t *data, uint32_t dataLen, uint32_t padbit)
{
uint32_t a[5], r[4];
uint64_t b[8];
// RFC_7539-2.5.1 for loop internal operation
a[0] = ctx->acc[0];
a[1] = ctx->acc[1];
a[2] = ctx->acc[2];
a[3] = ctx->acc[3];
a[4] = ctx->acc[4];
r[0] = ctx->r[0];
r[1] = ctx->r[1];
r[2] = ctx->r[2];
r[3] = ctx->r[3];
const uint8_t *off = data;
uint32_t len = dataLen;
while (len >= POLY1305_BLOCKSIZE) {
// a = acc + inputret
b[0] = (uint64_t)a[0] + GET_UINT32_LE(off, 0);
b[1] = (uint64_t)a[1] + GET_UINT32_LE(off, 4) + (b[0] >> 32);
b[2] = (uint64_t)a[2] + GET_UINT32_LE(off, 8) + (b[1] >> 32);
b[3] = (uint64_t)a[3] + GET_UINT32_LE(off, 12) + (b[2] >> 32);
a[0] = (uint32_t)b[0];
a[1] = (uint32_t)b[1];
a[2] = (uint32_t)b[2];
a[3] = (uint32_t)b[3];
// Upper 32 bits of b[3] carry to a[4]. Because a[4] <= 4, this processing can never overflow
a[4] += (uint32_t)(b[3] >> 32) + padbit;
/* Lower bits of the data product. Because the high bits of each term of r are processed,
there is no carry in the following polynomial multiplication and addition. */
b[0] = (uint64_t)a[0] * r[0];
b[1] = (uint64_t)a[0] * r[1] + (uint64_t)a[1] * r[0];
b[2] = (uint64_t)a[0] * r[2] + (uint64_t)a[1] * r[1] + (uint64_t)a[2] * r[0];
b[3] = (uint64_t)a[0] * r[3] + (uint64_t)a[1] * r[2] + (uint64_t)a[2] * r[1] + (uint64_t)a[3] * r[0];
/**
* Higher bits of the data product. Because the high bits of each term of r are processed,
* there is no carry in the following polynomial multiplication and addition.
*/
// (Ensure that the calculation (b[4] * 5) does not overflow, calculate (a[4] * r[0]) items later.)
b[4] = (uint64_t)a[1] * r[3] + (uint64_t)a[2] * r[2] + (uint64_t)a[3] * r[1];
b[5] = (uint64_t)a[2] * r[3] + (uint64_t)a[3] * r[2] + (uint64_t)a[4] * r[1];
b[6] = (uint64_t)a[3] * r[3] + (uint64_t)a[4] * r[2];
b[7] = (uint64_t)a[4] * r[3];
/**
* The upper bits are multiplied by 5/4, because r1, r[2], r3 is processed,
* so the above values are divisible by 4. Because the high bits of each term of r are processed,
* there is no carry in the following polynomial multiplication and addition: (3 * 5) < 0xF
*/
b[4] = (b[4] >> 2) + b[4];
b[5] = (b[5] >> 2) + b[5];
b[6] = (b[6] >> 2) + b[6];
b[7] = (b[7] >> 2) + b[7];
/* After offset 130 bits, the combination is obtained a0 = b[4] * 5 + b[0]....
Because the high bits of each term of r are processed,
there is no carry in the following polynomial multiplication and addition. */
b[0] += (b[4] & 0xFFFFFFFF);
b[1] += (b[0] >> 32) + (b[4] >> 32) + (b[5] & 0xFFFFFFFF);
b[2] += (b[1] >> 32) + (b[5] >> 32) + (b[6] & 0xFFFFFFFF);
b[3] += (b[2] >> 32) + (b[6] >> 32) + (b[7] & 0xFFFFFFFF);
a[4] = a[4] * r[0] + (uint32_t)(b[3] >> 32) + (uint32_t)(b[7] >> 32);
b[0] = (uint32_t)b[0];
b[1] = (uint32_t)b[1];
b[2] = (uint32_t)b[2];
b[3] = (uint32_t)b[3];
// Shift the upper bits of a4 by 130 bits and then multiply it by 5.
// The amount of a4 data is small and carry cannot be occurred.
b[0] += (a[4] >> 2) + (a[4] & 0xFFFFFFFC);
a[4] &= 0x3;
/* Process carry */
b[1] += (b[0] >> 32);
b[2] += (b[1] >> 32);
b[3] += (b[2] >> 32);
a[4] += (uint32_t)(b[3] >> 32);
a[0] = (uint32_t)b[0];
a[1] = (uint32_t)b[1];
a[2] = (uint32_t)b[2];
a[3] = (uint32_t)b[3];
len -= POLY1305_BLOCKSIZE;
off += POLY1305_BLOCKSIZE;
}
ctx->acc[0] = a[0];
ctx->acc[1] = a[1];
ctx->acc[2] = a[2];
ctx->acc[3] = a[3];
ctx->acc[4] = a[4];
// Clear sensitive information.
BSL_SAL_CleanseData(a, sizeof(a));
BSL_SAL_CleanseData(r, sizeof(r));
BSL_SAL_CleanseData(b, sizeof(b));
return len;
}
void Poly1305Last(Poly1305Ctx *ctx, uint8_t mac[POLY1305_TAGSIZE])
{
uint32_t a[5];
uint64_t b[5];
a[0] = ctx->acc[0];
a[1] = ctx->acc[1];
a[2] = ctx->acc[2];
a[3] = ctx->acc[3];
a[4] = ctx->acc[4];
/* Check whether it is greater than p. */
b[0] = (uint64_t)(a[0]) + 5;
b[1] = a[1] + (b[0] >> 32);
b[2] = a[2] + (b[1] >> 32);
b[3] = a[3] + (b[2] >> 32);
b[4] = a[4] + (b[3] >> 32);
/* Obtain the mask. If there is a carry, the number is greater than p. */
if ((b[4] & 0x4) == 0) { // b[4] & 0x4 is bit131.
b[0] = a[0];
b[1] = a[1];
b[2] = a[2];
b[3] = a[3];
}
// Adding s at the end does not require modulo processing.
b[0] = ctx->s[0] + (b[0] & 0xffffffff);
b[1] = ctx->s[1] + (b[1] & 0xffffffff) + (b[0] >> 32);
b[2] = ctx->s[2] + (b[2] & 0xffffffff) + (b[1] >> 32);
b[3] = ctx->s[3] + (b[3] & 0xffffffff) + (b[2] >> 32);
PUT_UINT32_LE(b[0], mac, 0);
PUT_UINT32_LE(b[1], mac, 4);
PUT_UINT32_LE(b[2], mac, 8);
PUT_UINT32_LE(b[3], mac, 12);
// Clear sensitive information.
BSL_SAL_CleanseData(a, sizeof(a));
BSL_SAL_CleanseData(b, sizeof(b));
}
// Clear the residual sensitive information in the register.
// This function is implemented only when the assembly function is enabled.
void Poly1305CleanRegister(void)
{
return;
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/noasm_poly1305.c | C | unknown | 6,568 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_CBC)
#include "crypt_modes_cbc.h"
#include "modes_local.h"
int32_t SM4_CBC_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CBC_Update(modeCtx, in, inLen, out, outLen);
}
int32_t SM4_CBC_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
return MODES_CBC_Final(modeCtx, out, outLen);
}
int32_t SM4_CBC_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_CBC_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
#endif
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/noasm_sm4_cbc.c | C | unknown | 1,219 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_CFB)
#include "crypt_modes_cfb.h"
#include "modes_local.h"
int32_t SM4_CFB_InitCtx(MODES_CFB_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_CFB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
int32_t SM4_CFB_Update(MODES_CFB_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CFB_Update(modeCtx, in, inLen, out, outLen);
}
#endif
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/noasm_sm4_cfb.c | C | unknown | 1,078 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_CTR)
#include "crypt_modes_ctr.h"
#include "modes_local.h"
int32_t SM4_CTR_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_CTR_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
int32_t SM4_CTR_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_CTR_Update(modeCtx, in, inLen, out, outLen);
}
#endif
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/noasm_sm4_ctr.c | C | unknown | 1,082 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_ECB)
#include "crypt_modes_ecb.h"
#include "modes_local.h"
int32_t SM4_ECB_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_ECB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
int32_t SM4_ECB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_ECB_Update(modeCtx, in, inLen, out, outLen);
}
int32_t SM4_ECB_Final(MODES_CipherCtx *modeCtx, uint8_t *out, uint32_t *outLen)
{
return MODES_ECB_Final(modeCtx, out, outLen);
}
#endif
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/noasm_sm4_ecb.c | C | unknown | 1,219 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_GCM)
#include "crypt_modes_gcm.h"
#include "modes_local.h"
int32_t SM4_GCM_InitCtx(MODES_GCM_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_GCM_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
int32_t SM4_GCM_Update(MODES_GCM_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_GCM_Update(modeCtx, in, inLen, out, outLen);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/noasm_sm4_gcm.c | C | unknown | 1,078 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_OFB)
#include "crypt_modes_ofb.h"
#include "modes_local.h"
int32_t SM4_OFB_InitCtx(MODES_CipherCtx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_OFB_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
int32_t SM4_OFB_Update(MODES_CipherCtx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_OFB_Update(modeCtx, in, inLen, out, outLen);
}
#endif
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/noasm_sm4_ofb.c | C | unknown | 1,083 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_SM4
#include "bsl_err_internal.h"
#include "crypt_sm4.h"
#include "modes_local.h"
/**
* @brief Set the encryption key.
*
* @param ctx [IN] Mode handle
* @param key [IN] Encrypt key
* @param len [IN] Encrypt key length. Only 16 bytes (128 bits) are supported.
* @return Success: CRYPT_SUCCESS
* Other error codes are returned if the operation fails.
*/
int32_t MODES_SM4_SetEncryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len)
{
return MODES_SetEncryptKey(ctx, key, len);
}
/**
* @brief Set the decryption key.
*
* @param ctx [IN] Mode handle
* @param key [IN] Decrypt key
* @param len [IN] Decrypt key length. Only 16 bytes (128 bits) are supported.
* @return Success: CRYPT_SUCCESS
* Other error codes are returned if the operation fails.
*/
int32_t MODES_SM4_SetDecryptKey(MODES_CipherCommonCtx *ctx, const uint8_t *key, uint32_t len)
{
return MODES_SetDecryptKey(ctx, key, len);
}
#endif // HITLS_CRYPTO_SM4
| 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/noasm_sm4_setkey.c | C | unknown | 1,564 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_SM4) && defined(HITLS_CRYPTO_XTS)
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "crypt_sm4.h"
#include "crypt_modes_xts.h"
#include "modes_local.h"
int32_t SM4_XTS_Update(MODES_XTS_Ctx *modeCtx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return MODES_XTS_Update(modeCtx, in, inLen, out, outLen);
}
int32_t SM4_XTS_InitCtx(MODES_XTS_Ctx *modeCtx, const uint8_t *key, uint32_t keyLen, const uint8_t *iv,
uint32_t ivLen, bool enc)
{
return MODES_XTS_InitCtx(modeCtx, key, keyLen, iv, ivLen, enc);
}
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/noasm_sm4_xts.c | C | unknown | 1,155 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef POLY1305_CORE_H
#define POLY1305_CORE_H
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
#include "crypt_modes_chacha20poly1305.h"
#include "modes_local.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
#define POLY1305_BLOCKSIZE 16
#define POLY1305_TAGSIZE 16
#define POLY1305_KEYSIZE 32
void Poly1305InitForAsm(Poly1305Ctx *ctx);
uint32_t Poly1305Block(Poly1305Ctx *ctx, const uint8_t *data, uint32_t dataLen, uint32_t padbit);
void Poly1305Last(Poly1305Ctx *ctx, uint8_t mac[POLY1305_TAGSIZE]);
void Poly1305CleanRegister(void);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // HITLS_CRYPTO_CHACHA20POLY1305
#endif // POLY1305_CORE_H | 2401_83913325/openHiTLS-examples_2461 | crypto/modes/src/poly1305_core.h | C | unknown | 1,266 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CRYPT_PAILLIER_H
#define CRYPT_PAILLIER_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PAILLIER
#include <stdlib.h>
#include <stdint.h>
#include "crypt_bn.h"
#include "crypt_local_types.h"
#include "bsl_params.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cpluscplus */
#define PAILLIER_MAX_MODULUS_BITS 16384
/* Paillier*/
typedef struct PAILLIER_Ctx CRYPT_PAILLIER_Ctx;
typedef struct PAILLIER_Para CRYPT_PAILLIER_Para;
/* Paillier method*/
/**
* @ingroup paillier
* @brief Allocate paillier context memory space.
*
* @retval (CRYPT_PAILLIER_Ctx *) Pointer to the memory space of the allocated context
* @retval NULL Invalid null pointer.
*/
CRYPT_PAILLIER_Ctx *CRYPT_PAILLIER_NewCtx(void);
/**
* @ingroup paillier
* @brief Allocate paillier context memory space.
* @param libCtx [IN] Library context
*
* @retval (CRYPT_PAILLIER_Ctx *) Pointer to the memory space of the allocated context
* @retval NULL Invalid null pointer.
*/
CRYPT_PAILLIER_Ctx *CRYPT_PAILLIER_NewCtxEx(void *libCtx);
/**
* @ingroup paillier
* @brief Copy the Paillier context. After the duplication is complete, call the CRYPT_PAILLIER_FreeCtx to release the memory.
*
* @param ctx [IN] PAILLIER context
*
* @return CRYPT_PAILLIER_Ctx Paillier context pointer
* If the operation fails, a null value is returned.
*/
CRYPT_PAILLIER_Ctx *CRYPT_PAILLIER_DupCtx(CRYPT_PAILLIER_Ctx *keyCtx);
/**
* @ingroup paillier
* @brief Create paillier key parameter structure
*
* @param para [IN] PAILLIER External parameter
*
* @retval (CRYPT_PAILLIER_Para *) Pointer to the allocated memory space of the structure
* @retval NULL Invalid null pointer.
*/
CRYPT_PAILLIER_Para *CRYPT_PAILLIER_NewPara(const CRYPT_PaillierPara *para);
/**
* @ingroup paillier
* @brief release paillier key context structure
*
* @param ctx [IN] Pointer to the context structure to be released. The ctx is set NULL by the invoker.
*/
void CRYPT_PAILLIER_FreeCtx(CRYPT_PAILLIER_Ctx *ctx);
/**
* @ingroup paillier
* @brief Release paillier key parameter structure
*
* @param para [IN] Storage pointer in the parameter structure to be released. The parameter is set NULL by the invoker.
*/
void CRYPT_PAILLIER_FreePara(CRYPT_PAILLIER_Para *para);
/**
* @ingroup paillier
* @brief Set the data of the key parameter structure to the key structure.
*
* @param ctx [OUT] Paillier context structure for which related parameters need to be set
* @param para [IN] Key parameter structure
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input.
* @retval CRYPT_PAILLIER_ERR_KEY_BITS The expected key length does not meet the requirements.
* @retval CRYPT_PAILLIER_ERR_E_VALUE The expected value of e does not meet the requirements.
* @retval CRYPT_MEM_ALLOC_FAIL internal memory allocation error
* @retval CRYPT_SUCCESS set successfully.
*/
int32_t CRYPT_PAILLIER_SetPara(CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PaillierPara *para);
/**
* @ingroup paillier
* @brief Obtain the valid length of the key.
*
* @param ctx [IN] Structure from which the key length is expected to be obtained
*
* @retval 0: The input is incorrect or the corresponding key structure does not have a valid key length.
* @retval uint32_t: Valid key length
*/
uint32_t CRYPT_PAILLIER_GetBits(const CRYPT_PAILLIER_Ctx *ctx);
/**
* @ingroup paillier
* @brief Generate the Paillier key pair.
*
* @param ctx [IN/OUT] paillier context structure
*
* @retval CRYPT_NULL_INPUT Error null pointer input
* @retval CRYPT_PAILLIER_ERR_KEY_BITS The value of e in the context structure does not meet the requirements.
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The key pair is successfully generated.
*/
int32_t CRYPT_PAILLIER_Gen(CRYPT_PAILLIER_Ctx *ctx);
/**
* @ingroup paillier
* @brief Paillier public key encryption
*
* @param ctx [IN] Paillier context structure
* @param input [IN] Information to be encrypted
* @param inputLen [IN] Length of the information to be encrypted
* @param out [OUT] Pointer to the encrypted information output.
* @param outLen [IN/OUT] Pointer to the length of the encrypted information.
* Before being transferred, the value must be set to the maximum length of the array.
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input
* @retval CRYPT_PAILLIER_NO_KEY_INFO does not contain the key information.
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions.
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval CRYPT_SECUREC_FAIL A security function error occurs.
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS encryption succeeded.
*/
int32_t CRYPT_PAILLIER_PubEnc(const CRYPT_PAILLIER_Ctx *ctx, const uint8_t *input, uint32_t inputLen,
uint8_t *out, uint32_t *outLen);
/**
* @ingroup paillier
* @brief Paillier private key decryption
*
* @param ctx [IN] Paillier context structure
* @param ciphertext [IN] Information to be decrypted
* @param bits [IN] Length of the information to be decrypted
* @param out [OUT] Pointer to the decrypted information output.
* @param outLen [IN/OUT] Pointer to the length of the decrypted information.
* Before being transferred, the value must be set to the maximum length of the array.
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input
* @retval CRYPT_PAILLIER_ERR_DEC_BITS Incorrect length of the encrypted private key.
* @retval CRYPT_PAILLIER_NO_KEY_INFO does not contain the key information.
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions.
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval CRYPT_SECUREC_FAIL A security function error occurs.
* @retval BN error. An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS Decrypted Successfully
*/
int32_t CRYPT_PAILLIER_PrvDec(const CRYPT_PAILLIER_Ctx *ctx, const BN_BigNum *ciphertext, uint32_t bits,
uint8_t *out, uint32_t *outLen);
/**
* @ingroup paillier
* @brief Paillier Set the private key information.
*
* @param ctx [OUT] paillier context structure
* @param prv [IN] Private key data
*
* @retval CRYPT_NULL_INPUT Error null pointer input
* @retval CRYPT_PAILLIER_ERR_KEY_BITS The key length does not meet the requirements.
* @retval CRYPT_PAILLIER_NO_KEY_INFO does not contain the key information.
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions.
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The private key is successfully set.
*/
int32_t CRYPT_PAILLIER_SetPrvKey(CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PaillierPrv *prv);
/**
* @ingroup paillier
* @brief Paillier Set the public key information.
*
* @param ctx [OUT] Paillier context structure
* @param pub [IN] Public key data
*
* @retval CRYPT_NULL_INPUT Error null pointer input
* @retval CRYPT_PAILLIER_ERR_KEY_BITS The key length does not meet the requirements.
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions.
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The public key is successfully set.
*/
int32_t CRYPT_PAILLIER_SetPubKey(CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PaillierPub *pub);
/**
* @ingroup paillier
* @brief Paillier Obtain the private key information.
*
* @param ctx [IN] Paillier context structure
* @param prv [OUT] Private key data
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The private key is obtained successfully.
*/
int32_t CRYPT_PAILLIER_GetPrvKey(const CRYPT_PAILLIER_Ctx *ctx, CRYPT_PaillierPrv *prv);
/**
* @ingroup paillier
* @brief Paillier Obtain the public key information.
*
* @param ctx [IN] Paillier context structure
* @param pub [OUT] Public key data
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The public key is obtained successfully.
*/
int32_t CRYPT_PAILLIER_GetPubKey(const CRYPT_PAILLIER_Ctx *ctx, CRYPT_PaillierPub *pub);
#ifdef HITLS_BSL_PARAMS
/**
* @ingroup paillier
* @brief Set the data of the key parameter structure to the key structure.
*
* @param ctx [OUT] Paillier context structure for which related parameters need to be set
* @param para [IN] Key parameter structure
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input.
* @retval CRYPT_PAILLIER_ERR_KEY_BITS The expected key length does not meet the requirements.
* @retval CRYPT_PAILLIER_ERR_E_VALUE The expected value of e does not meet the requirements.
* @retval CRYPT_MEM_ALLOC_FAIL internal memory allocation error
* @retval CRYPT_SUCCESS set successfully.
*/
int32_t CRYPT_PAILLIER_SetParaEx(CRYPT_PAILLIER_Ctx *ctx, const BSL_Param *para);
/**
* @ingroup paillier
* @brief Paillier Set the private key information.
*
* @param ctx [OUT] paillier context structure
* @param prv [IN] Private key data
*
* @retval CRYPT_NULL_INPUT Error null pointer input
* @retval CRYPT_PAILLIER_ERR_KEY_BITS The key length does not meet the requirements.
* @retval CRYPT_PAILLIER_NO_KEY_INFO does not contain the key information.
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions.
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The private key is successfully set.
*/
int32_t CRYPT_PAILLIER_SetPrvKeyEx(CRYPT_PAILLIER_Ctx *ctx, const BSL_Param *para);
/**
* @ingroup paillier
* @brief Paillier Set the public key information.
*
* @param ctx [OUT] Paillier context structure
* @param pub [IN] Public key data
*
* @retval CRYPT_NULL_INPUT Error null pointer input
* @retval CRYPT_PAILLIER_ERR_KEY_BITS The key length does not meet the requirements.
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions.
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The public key is successfully set.
*/
int32_t CRYPT_PAILLIER_SetPubKeyEx(CRYPT_PAILLIER_Ctx *ctx, const BSL_Param *para);
/**
* @ingroup paillier
* @brief Paillier Obtain the private key information.
*
* @param ctx [IN] Paillier context structure
* @param prv [OUT] Private key data
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The private key is obtained successfully.
*/
int32_t CRYPT_PAILLIER_GetPrvKeyEx(const CRYPT_PAILLIER_Ctx *ctx, BSL_Param *para);
/**
* @ingroup paillier
* @brief Paillier Obtain the public key information.
*
* @param ctx [IN] Paillier context structure
* @param pub [OUT] Public key data
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input
* @retval BN error An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS The public key is obtained successfully.
*/
int32_t CRYPT_PAILLIER_GetPubKeyEx(const CRYPT_PAILLIER_Ctx *ctx, BSL_Param *para);
#endif
/**
* @ingroup paillier
* @brief PAILLIER public key encryption
*
* @param ctx [IN] PAILLIER context structure
* @param data [IN] Information to be encrypted
* @param dataLen [IN] Length of the information to be encrypted
* @param out [OUT] Pointer to the encrypted information output.
* @param outLen [OUT] Pointer to the length of the encrypted information
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input
* @retval CRYPT_PAILLIER_NO_KEY_INFO does not contain the key information.
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions.
* @retval CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH Outbuf Insufficient
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval CRYPT_SECUREC_FAIL A safe function error occurs.
* @retval BN error. An error occurs in the internal BigNum operation.
* @retval CRYPT_EAL_ALG_NOT_SUPPORT does not register the encryption method.
* @retval CRYPT_SUCCESS encryption succeeded.
*/
int32_t CRYPT_PAILLIER_Encrypt(CRYPT_PAILLIER_Ctx *ctx, const uint8_t *data, uint32_t dataLen,
uint8_t *out, uint32_t *outLen);
/**
* @ingroup paillier
* @brief PAILLIER private key decryption
*
* @param ctx [IN] PAILLIER context structure
* @param data [IN] Information to be decrypted
* @param dataLen [IN] Length of the information to be decrypted
* @param out [OUT] Pointer to the output information after decryption.
* @param outLen [OUT] Pointer to the length of the decrypted information
*
* @retval CRYPT_NULL_INPUT Error null pointer input
* @retval CRYPT_PAILLIER_NO_KEY_INFO does not contain the key information.
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions.
* @retval CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH Outbuf Insufficient
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval CRYPT_SECUREC_FAIL A security function error occurs.
* @retval CRYPT_EAL_ALG_NOT_SUPPORT does not register the decryption method.
* @retval BN error. An error occurs in the internal BigNum operation.
* @retval CRYPT_SUCCESS Decryption succeeded.
*/
int32_t CRYPT_PAILLIER_Decrypt(CRYPT_PAILLIER_Ctx *ctx, const uint8_t *data, uint32_t dataLen,
uint8_t *out, uint32_t *outLen);
/**
* @ingroup paillier
* @brief PAILLIER get security bits
*
* @param ctx [IN] PAILLIER Context structure
*
* @retval security bits
*/
int32_t CRYPT_PAILLIER_GetSecBits(const CRYPT_PAILLIER_Ctx *ctx);
/**
* @ingroup paillier
* @brief PAILLIER control function for various operations
*
* @param ctx [IN/OUT] PAILLIER context structure
* @param opt [IN] Control operation type
* @param val [IN/OUT] Parameter value for the operation
* @param len [IN] Length of the parameter value
*
* @retval CRYPT_NULL_INPUT Invalid null pointer input
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE The entered value does not meet the calculation conditions
* @retval CRYPT_PAILLIER_NO_KEY_INFO Does not contain the key information
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval CRYPT_EAL_ALG_NOT_SUPPORT Operation not supported
* @retval CRYPT_SUCCESS Operation succeeded
*/
int32_t CRYPT_PAILLIER_Ctrl(CRYPT_PAILLIER_Ctx *ctx, int32_t opt, void *val, uint32_t len);
/**
* @ingroup paillier
* @brief PAILLIER homomorphic addition operation (c_res = c1 * c2 mod n^2)
*
* @param ctx [IN] Paillier context structure
* @param input [IN] Addition operands, must include two ciphertext parameters
* @param out [OUT] The result of the addition operation
* @param outLen [IN/OUT] Pointer to the length of the output buffer
*
* @retval CRYPT_NULL_INPUT Any input pointer is NULL
* @retval CRYPT_PAILLIER_NO_KEY_INFO Context does not contain valid public key information
* @retval CRYPT_PAILLIER_ERR_INPUT_VALUE Input ciphertext value is incorrect
* @retval CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH Output buffer length is insufficient
* @retval CRYPT_MEM_ALLOC_FAIL Memory allocation failure
* @retval CRYPT_SUCCESS Operation succeeded, result is written to out
*/
int32_t CRYPT_PAILLIER_Add(const void *ctx, const BSL_Param *input, uint8_t *out, uint32_t *outLen);
#ifdef __cplusplus
}
#endif
#endif // HITLS_CRYPTO_PAILLIER
#endif // CRYPT_PAILLIER_H | 2401_83913325/openHiTLS-examples_2461 | crypto/paillier/include/crypt_paillier.h | C | unknown | 17,517 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PAILLIER
#include "crypt_utils.h"
#include "crypt_paillier.h"
#include "paillier_local.h"
#include "crypt_errno.h"
#include "bsl_sal.h"
#include "securec.h"
#include "bsl_err_internal.h"
int32_t CRYPT_PAILLIER_PubEnc(const CRYPT_PAILLIER_Ctx *ctx, const uint8_t *input, uint32_t inputLen,
uint8_t *out, uint32_t *outLen)
{
int32_t ret;
CRYPT_PAILLIER_PubKey *pubKey = ctx->pubKey;
if (pubKey == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
uint32_t bits = CRYPT_PAILLIER_GetBits(ctx);
BN_Optimizer *optimizer = BN_OptimizerCreate();
if (optimizer == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
BN_BigNum *m = BN_Create(bits);
BN_BigNum *r = BN_Create(bits);
BN_BigNum *gm = BN_Create(bits);
BN_BigNum *rn = BN_Create(bits);
BN_BigNum *result = BN_Create(bits);
BN_BigNum *gcd_result = BN_Create(bits);
bool createFailed = (m == NULL || r == NULL || gm == NULL || rn == NULL || result == NULL || gcd_result == NULL);
if (createFailed) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
ret = CRYPT_MEM_ALLOC_FAIL;
goto EXIT;
}
ret = BN_Bin2Bn(m, input, inputLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
// Check whether m is less than n and non-negative
if (BN_Cmp(m, pubKey->n) >= 0 || BN_IsNegative(m)) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
ret = CRYPT_PAILLIER_ERR_INPUT_VALUE;
goto EXIT;
}
ret = BN_RandRangeEx(ctx->libCtx, r, pubKey->n);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
while (true) {
// Check whether r is relatively prime to n, if not, regenerate r
ret = BN_Gcd(gcd_result, r, pubKey->n, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
if (BN_IsOne(gcd_result)) {
break;
}
ret = BN_RandRangeEx(ctx->libCtx, r, pubKey->n);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
}
ret = BN_ModExp(gm, pubKey->g, m, pubKey->n2, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_ModExp(rn, r, pubKey->n, pubKey->n2, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_ModMul(result, gm, rn, pubKey->n2, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_Bn2Bin(result, out, outLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
EXIT:
BN_Destroy(m);
BN_Destroy(r);
BN_Destroy(gm);
BN_Destroy(rn);
BN_Destroy(result);
BN_Destroy(gcd_result);
BN_OptimizerDestroy(optimizer);
return ret;
}
int32_t CRYPT_PAILLIER_PrvDec(const CRYPT_PAILLIER_Ctx *ctx, const BN_BigNum *ciphertext, uint32_t bits,
uint8_t *out, uint32_t *outLen)
{
int32_t ret;
CRYPT_PAILLIER_PrvKey *prvKey = ctx->prvKey;
if (prvKey == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
BN_Optimizer *optimizer = BN_OptimizerCreate();
if (optimizer == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
BN_BigNum *m = BN_Create(bits);
BN_BigNum *result = BN_Create(bits);
bool createFailed = (m == NULL || result == NULL);
if (createFailed) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
ret = CRYPT_MEM_ALLOC_FAIL;
goto EXIT;
}
ret = BN_ModExp(m, ciphertext, prvKey->lambda, prvKey->n2, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_SubLimb(result, m, 1);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_Div(result, NULL, result, prvKey->n, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_ModMul(result, result, prvKey->mu, prvKey->n, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_Bn2Bin(result, out, outLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
EXIT:
BN_Destroy(m);
BN_Destroy(result);
BN_OptimizerDestroy(optimizer);
return ret;
}
static int32_t EncryptInputCheck(const CRYPT_PAILLIER_Ctx *ctx, const uint8_t *input, uint32_t inputLen,
const uint8_t *out, const uint32_t *outLen)
{
if (ctx == NULL || (input == NULL && inputLen != 0) || out == NULL || outLen == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ctx->pubKey == NULL) {
// Check whether the public key information exists.
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_NO_KEY_INFO);
return CRYPT_PAILLIER_NO_KEY_INFO;
}
// Check whether the length of the out is sufficient to place the encryption information.
uint32_t bits = CRYPT_PAILLIER_GetBits(ctx);
if ((*outLen) < BN_BITS_TO_BYTES(bits)) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH);
return CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH;
}
if (inputLen > BN_BITS_TO_BYTES(bits)) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_ENC_BITS);
return CRYPT_PAILLIER_ERR_ENC_BITS;
}
return CRYPT_SUCCESS;
}
int32_t CRYPT_PAILLIER_Encrypt(CRYPT_PAILLIER_Ctx *ctx, const uint8_t *data, uint32_t dataLen,
uint8_t *out, uint32_t *outLen)
{
int32_t ret = EncryptInputCheck(ctx, data, dataLen, out, outLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
ret = CRYPT_PAILLIER_PubEnc(ctx, data, dataLen, out, outLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
static int32_t DecryptInputCheck(const CRYPT_PAILLIER_Ctx *ctx, const uint8_t *data, uint32_t dataLen,
const uint8_t *out, const uint32_t *outLen)
{
if (ctx == NULL || data == NULL || out == NULL || outLen == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ctx->prvKey == NULL) {
// Check whether the private key information exists.
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_NO_KEY_INFO);
return CRYPT_PAILLIER_NO_KEY_INFO;
}
// Check whether the length of the out is sufficient to place the decryption information.
uint32_t bits = CRYPT_PAILLIER_GetBits(ctx);
if ((*outLen) < BN_BITS_TO_BYTES(bits)) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH);
return CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH;
}
if (dataLen != BN_BITS_TO_BYTES(bits) * 2) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_DEC_BITS);
return CRYPT_PAILLIER_ERR_DEC_BITS;
}
return CRYPT_SUCCESS;
}
static int32_t CRYPT_PAILLIER_CheckCiphertext(const BN_BigNum* ciphertext, const CRYPT_PAILLIER_PrvKey* prvKey)
{
if (BN_Cmp(ciphertext, prvKey->n2) >= 0 || BN_IsNegative(ciphertext)) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
return CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
int32_t ret = CRYPT_SUCCESS;
BN_BigNum *gcd_result = BN_Create(BN_Bits(ciphertext));
BN_Optimizer *optimizer = BN_OptimizerCreate();
if (gcd_result == NULL || optimizer == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
ret = CRYPT_MEM_ALLOC_FAIL;
goto EXIT;
}
ret = BN_Gcd(gcd_result, ciphertext, prvKey->n2, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
if (BN_IsOne(gcd_result) == false) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
ret = CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
EXIT:
BN_Destroy(gcd_result);
BN_OptimizerDestroy(optimizer);
return ret;
}
int32_t CRYPT_PAILLIER_Decrypt(CRYPT_PAILLIER_Ctx *ctx, const uint8_t *data, uint32_t dataLen,
uint8_t *out, uint32_t *outLen)
{
int32_t ret = DecryptInputCheck(ctx, data, dataLen, out, outLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
uint32_t bits = CRYPT_PAILLIER_GetBits(ctx);
BN_BigNum *c = BN_Create(bits);
if (c == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
ret = BN_Bin2Bn(c, data, dataLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
// check whether c is in Zn2*
ret = CRYPT_PAILLIER_CheckCiphertext(c, ctx->prvKey);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = CRYPT_PAILLIER_PrvDec(ctx, c, bits, out, outLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
EXIT:
BN_Destroy(c);
return ret;
}
static int32_t CRYPT_PAILLIER_GetLen(const CRYPT_PAILLIER_Ctx *ctx, GetLenFunc func, void *val, uint32_t len)
{
if (val == NULL || len != sizeof(int32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
*(int32_t *)val = func(ctx);
return CRYPT_SUCCESS;
}
int32_t CRYPT_PAILLIER_Ctrl(CRYPT_PAILLIER_Ctx *ctx, int32_t opt, void *val, uint32_t len)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
switch (opt) {
case CRYPT_CTRL_GET_BITS:
return CRYPT_PAILLIER_GetLen(ctx, (GetLenFunc)CRYPT_PAILLIER_GetBits, val, len);
case CRYPT_CTRL_GET_SECBITS:
return CRYPT_PAILLIER_GetLen(ctx, (GetLenFunc)CRYPT_PAILLIER_GetSecBits, val, len);
default:
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_CTRL_NOT_SUPPORT_ERROR);
return CRYPT_PAILLIER_CTRL_NOT_SUPPORT_ERROR;
}
}
static int32_t CRYPT_PAILLIER_CheckHECiphertext(const BN_BigNum* ciphertext, const CRYPT_PAILLIER_PubKey* pubKey,
BN_Optimizer *optimizer)
{
if (BN_Cmp(ciphertext, pubKey->n2) >= 0 || BN_IsNegative(ciphertext)) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
return CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
int32_t ret = CRYPT_SUCCESS;
BN_BigNum *gcd_result = BN_Create(BN_Bits(ciphertext));
if (gcd_result == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
ret = CRYPT_MEM_ALLOC_FAIL;
goto EXIT;
}
ret = BN_Gcd(gcd_result, ciphertext, pubKey->n2, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
if (BN_IsOne(gcd_result) == false) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
ret = CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
EXIT:
BN_Destroy(gcd_result);
return ret;
}
int32_t CRYPT_PAILLIER_Add(const void *ctx, const BSL_Param *input, uint8_t *out, uint32_t *outLen)
{
if (ctx == NULL || input == NULL || out == NULL || outLen == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
const CRYPT_PAILLIER_Ctx *paillierCtx = ctx;
if (paillierCtx == NULL || paillierCtx->pubKey == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_NO_KEY_INFO);
return CRYPT_PAILLIER_NO_KEY_INFO;
}
const BSL_Param *ciphertext1Param = BSL_PARAM_FindConstParam(input, CRYPT_PARAM_PKEY_HE_CIPHERTEXT1);
const BSL_Param *ciphertext2Param = BSL_PARAM_FindConstParam(input, CRYPT_PARAM_PKEY_HE_CIPHERTEXT2);
if (ciphertext1Param == NULL || ciphertext2Param == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
return CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
uint32_t bits = CRYPT_PAILLIER_GetBits(paillierCtx);
uint32_t n2Bytes = BN_BITS_TO_BYTES(bits) * 2;
int32_t ret = CRYPT_SUCCESS;
uint8_t *ciphertext1 = (uint8_t *)BSL_SAL_Malloc(n2Bytes);
uint8_t *ciphertext2 = (uint8_t *)BSL_SAL_Malloc(n2Bytes);
uint32_t ciphertext1Len = n2Bytes;
uint32_t ciphertext2Len = n2Bytes;
if (ciphertext1 == NULL || ciphertext2 == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
BSL_SAL_Free(ciphertext1);
BSL_SAL_Free(ciphertext2);
return CRYPT_MEM_ALLOC_FAIL;
}
BN_BigNum *c1 = BN_Create(bits);
BN_BigNum *c2 = BN_Create(bits);
BN_BigNum *result = BN_Create(bits);
if (c1 == NULL || c2 == NULL || result == NULL) {
ret = CRYPT_MEM_ALLOC_FAIL;
BN_Destroy(c1);
BN_Destroy(c2);
BN_Destroy(result);
BSL_SAL_Free(ciphertext1);
BSL_SAL_Free(ciphertext2);
return ret;
}
BN_Optimizer *optimizer = BN_OptimizerCreate();
if (optimizer == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
goto EXIT;
}
if (BSL_PARAM_GetValue(ciphertext1Param, CRYPT_PARAM_PKEY_HE_CIPHERTEXT1, BSL_PARAM_TYPE_OCTETS, ciphertext1,
&ciphertext1Len) != BSL_SUCCESS ||
BSL_PARAM_GetValue(ciphertext2Param, CRYPT_PARAM_PKEY_HE_CIPHERTEXT2, BSL_PARAM_TYPE_OCTETS, ciphertext2,
&ciphertext2Len) != BSL_SUCCESS) {
ret = CRYPT_PAILLIER_ERR_INPUT_VALUE;
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
// Check whether the input ciphertext meets the specifications
if (ciphertext1Len != n2Bytes || ciphertext2Len != n2Bytes) {
ret = CRYPT_PAILLIER_ERR_INPUT_VALUE;
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
// Check whether the length of the out is sufficient to place the result
if (*outLen < n2Bytes) {
ret = CRYPT_PAILLIER_BUFF_LEN_NOT_ENOUGH;
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
if ((ret = BN_Bin2Bn(c1, ciphertext1, ciphertext1Len)) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
if ((ret = BN_Bin2Bn(c2, ciphertext2, ciphertext2Len)) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
// Verify that the ciphertext is within the valid range [0, n^2)
if ((ret = CRYPT_PAILLIER_CheckHECiphertext(c1, paillierCtx->pubKey, optimizer))!= CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
if ((ret = CRYPT_PAILLIER_CheckHECiphertext(c2, paillierCtx->pubKey, optimizer))!= CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
// Add: c_res = c1 * c2 mod n^2
if ((ret = BN_ModMul(result, c1, c2, paillierCtx->pubKey->n2, optimizer)) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
// Export result as fixed-length n^2 bytes with leading-zero padding
uint8_t *tmpBuf = (uint8_t *)BSL_SAL_Malloc(n2Bytes);
if (tmpBuf == NULL) {
ret = CRYPT_MEM_ALLOC_FAIL;
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
uint32_t actualLen = n2Bytes;
ret = BN_Bn2Bin(result, tmpBuf, &actualLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
BSL_SAL_Free(tmpBuf);
goto EXIT;
}
(void)memset_s(out, n2Bytes, 0, n2Bytes);
if (actualLen > 0) {
(void)memcpy_s(out + (n2Bytes - actualLen), actualLen, tmpBuf, actualLen);
}
*outLen = n2Bytes;
BSL_SAL_Free(tmpBuf);
EXIT:
BN_Destroy(c1);
BN_Destroy(c2);
BN_Destroy(result);
BN_OptimizerDestroy(optimizer);
BSL_SAL_Free(ciphertext1);
BSL_SAL_Free(ciphertext2);
return ret;
}
#endif // HITLS_CRYPTO_PAILLIER | 2401_83913325/openHiTLS-examples_2461 | crypto/paillier/src/paillier_encdec.c | C | unknown | 16,085 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PAILLIER
#include "crypt_paillier.h"
#include "paillier_local.h"
#include "crypt_errno.h"
#include "crypt_utils.h"
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_params_key.h"
CRYPT_PAILLIER_Ctx *CRYPT_PAILLIER_NewCtx(void)
{
CRYPT_PAILLIER_Ctx *ctx = NULL;
ctx = (CRYPT_PAILLIER_Ctx *)BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_Ctx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
(void)memset_s(ctx, sizeof(CRYPT_PAILLIER_Ctx), 0, sizeof(CRYPT_PAILLIER_Ctx));
BSL_SAL_ReferencesInit(&(ctx->references));
return ctx;
}
CRYPT_PAILLIER_Ctx *CRYPT_PAILLIER_NewCtxEx(void *libCtx)
{
CRYPT_PAILLIER_Ctx *ctx = CRYPT_PAILLIER_NewCtx();
if (ctx == NULL) {
return NULL;
}
ctx->libCtx = libCtx;
return ctx;
}
static CRYPT_PAILLIER_PubKey *PaillierPubKeyDupCtx(CRYPT_PAILLIER_PubKey *pubKey)
{
CRYPT_PAILLIER_PubKey *newPubKey = (CRYPT_PAILLIER_PubKey *)BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_PubKey));
if (newPubKey == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
(void)memset_s(newPubKey, sizeof(CRYPT_PAILLIER_PubKey), 0, sizeof(CRYPT_PAILLIER_PubKey));
GOTO_ERR_IF_SRC_NOT_NULL(newPubKey->n, pubKey->n, BN_Dup(pubKey->n), CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_SRC_NOT_NULL(newPubKey->g, pubKey->g, BN_Dup(pubKey->g), CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_SRC_NOT_NULL(newPubKey->n2, pubKey->n2, BN_Dup(pubKey->n2), CRYPT_MEM_ALLOC_FAIL);
return newPubKey;
ERR:
PAILLIER_FREE_PUB_KEY(newPubKey);
return NULL;
}
static CRYPT_PAILLIER_PrvKey *PaillierPrvKeyDupCtx(CRYPT_PAILLIER_PrvKey *prvKey)
{
CRYPT_PAILLIER_PrvKey *newPrvKey = (CRYPT_PAILLIER_PrvKey *)BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_PrvKey));
if (newPrvKey == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
(void)memset_s(newPrvKey, sizeof(CRYPT_PAILLIER_PrvKey), 0, sizeof(CRYPT_PAILLIER_PrvKey));
GOTO_ERR_IF_SRC_NOT_NULL(newPrvKey->n, prvKey->n, BN_Dup(prvKey->n), CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_SRC_NOT_NULL(newPrvKey->lambda, prvKey->lambda, BN_Dup(prvKey->lambda), CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_SRC_NOT_NULL(newPrvKey->mu, prvKey->mu, BN_Dup(prvKey->mu), CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_SRC_NOT_NULL(newPrvKey->n2, prvKey->n2, BN_Dup(prvKey->n2), CRYPT_MEM_ALLOC_FAIL);
return newPrvKey;
ERR:
PAILLIER_FREE_PRV_KEY(newPrvKey);
return NULL;
}
static CRYPT_PAILLIER_Para *PaillierParaDupCtx(CRYPT_PAILLIER_Para *para)
{
CRYPT_PAILLIER_Para *newPara = (CRYPT_PAILLIER_Para *)BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_Para));
if (newPara == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
(void)memset_s(newPara, sizeof(CRYPT_PAILLIER_Para), 0, sizeof(CRYPT_PAILLIER_Para));
newPara->bits = para->bits;
GOTO_ERR_IF_SRC_NOT_NULL(newPara->p, para->p, BN_Dup(para->p), CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_SRC_NOT_NULL(newPara->q, para->q, BN_Dup(para->q), CRYPT_MEM_ALLOC_FAIL);
return newPara;
ERR:
PAILLIER_FREE_PARA(newPara);
return NULL;
}
CRYPT_PAILLIER_Ctx *CRYPT_PAILLIER_DupCtx(CRYPT_PAILLIER_Ctx *keyCtx)
{
if (keyCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return NULL;
}
CRYPT_PAILLIER_Ctx *newKeyCtx = NULL;
newKeyCtx = BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_Ctx));
if (newKeyCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
(void)memset_s(newKeyCtx, sizeof(CRYPT_PAILLIER_Ctx), 0, sizeof(CRYPT_PAILLIER_Ctx));
GOTO_ERR_IF_SRC_NOT_NULL(newKeyCtx->prvKey, keyCtx->prvKey, PaillierPrvKeyDupCtx(keyCtx->prvKey),
CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_SRC_NOT_NULL(newKeyCtx->pubKey, keyCtx->pubKey, PaillierPubKeyDupCtx(keyCtx->pubKey),
CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_SRC_NOT_NULL(newKeyCtx->para, keyCtx->para, PaillierParaDupCtx(keyCtx->para), CRYPT_MEM_ALLOC_FAIL);
newKeyCtx->libCtx = keyCtx->libCtx;
BSL_SAL_ReferencesInit(&(newKeyCtx->references));
return newKeyCtx;
ERR:
CRYPT_PAILLIER_FreeCtx(newKeyCtx);
return NULL;
}
static int32_t PaillierNewParaBasicCheck(const CRYPT_PaillierPara *para)
{
if (para == NULL || para->p == NULL || para->pLen == 0 || para->q == NULL ||
para->qLen == 0 || para->bits <= 0 || para->bits > PAILLIER_MAX_MODULUS_BITS) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
/* the length of p and q should be equal to bits */
if (para->pLen != BN_BITS_TO_BYTES(para->bits) || para->qLen != BN_BITS_TO_BYTES(para->bits)) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_KEY_BITS);
return CRYPT_PAILLIER_ERR_KEY_BITS;
}
return CRYPT_SUCCESS;
}
CRYPT_PAILLIER_Para *CRYPT_PAILLIER_NewPara(const CRYPT_PaillierPara *para)
{
int32_t ret = PaillierNewParaBasicCheck(para);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return NULL;
}
CRYPT_PAILLIER_Para *retPara = BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_Para));
if (retPara == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
retPara->bits = para->bits;
retPara->p = BN_Create(para->bits);
retPara->q = BN_Create(para->bits);
if (retPara->p == NULL || retPara->q == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
goto ERR;
}
return retPara;
ERR:
CRYPT_PAILLIER_FreePara(retPara);
return NULL;
}
void CRYPT_PAILLIER_FreeCtx(CRYPT_PAILLIER_Ctx *ctx)
{
if (ctx == NULL) {
return;
}
int i = 0;
BSL_SAL_AtomicDownReferences(&(ctx->references), &i);
if (i > 0) {
return;
}
BSL_SAL_ReferencesFree(&(ctx->references));
PAILLIER_FREE_PRV_KEY(ctx->prvKey);
PAILLIER_FREE_PUB_KEY(ctx->pubKey);
PAILLIER_FREE_PARA(ctx->para);
BSL_SAL_Free(ctx);
}
void CRYPT_PAILLIER_FreePara(CRYPT_PAILLIER_Para *para)
{
if (para == NULL) {
return;
}
BN_Destroy(para->p);
BN_Destroy(para->q);
BSL_SAL_Free(para);
}
void PAILLIER_FreePrvKey(CRYPT_PAILLIER_PrvKey *prvKey)
{
if (prvKey == NULL) {
return;
}
BN_Destroy(prvKey->n);
BN_Destroy(prvKey->lambda);
BN_Destroy(prvKey->mu);
BN_Destroy(prvKey->n2);
BSL_SAL_Free(prvKey);
}
void PAILLIER_FreePubKey(CRYPT_PAILLIER_PubKey *pubKey)
{
if (pubKey == NULL) {
return;
}
BN_Destroy(pubKey->n);
BN_Destroy(pubKey->g);
BN_Destroy(pubKey->n2);
BSL_SAL_Free(pubKey);
}
static int32_t IsPAILLIERSetParaVaild(const CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PAILLIER_Para *para)
{
if (ctx == NULL || para == NULL || para->p == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (para->bits > PAILLIER_MAX_MODULUS_BITS || para->bits <= 0) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_KEY_BITS);
return CRYPT_PAILLIER_ERR_KEY_BITS;
}
return CRYPT_SUCCESS;
}
CRYPT_PAILLIER_Para *CRYPT_Paillier_DupPara(const CRYPT_PAILLIER_Para *para)
{
CRYPT_PAILLIER_Para *paraCopy = BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_Para));
if (paraCopy == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
paraCopy->bits = para->bits;
paraCopy->p = BN_Dup(para->p);
paraCopy->q = BN_Dup(para->q);
if (paraCopy->p == NULL || paraCopy->q == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
PAILLIER_FREE_PARA(paraCopy);
return NULL;
}
return paraCopy;
}
int32_t CRYPT_PAILLIER_SetPara(CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PaillierPara *para)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
CRYPT_PAILLIER_Para *paillierPara = CRYPT_PAILLIER_NewPara(para);
if (paillierPara == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
int32_t ret = IsPAILLIERSetParaVaild(ctx, paillierPara);
if (ret != CRYPT_SUCCESS) {
CRYPT_PAILLIER_FreePara(paillierPara);
return ret;
}
PAILLIER_FREE_PARA(ctx->para);
PAILLIER_FREE_PUB_KEY(ctx->pubKey);
PAILLIER_FREE_PRV_KEY(ctx->prvKey);
ctx->para = paillierPara;
return CRYPT_SUCCESS;
}
#ifdef HITLS_BSL_PARAMS
int32_t CRYPT_PAILLIER_SetParaEx(CRYPT_PAILLIER_Ctx *ctx, const BSL_Param *para)
{
if (para == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
CRYPT_PaillierPara paillierPara = {0};
uint32_t bitsLen = sizeof(uint32_t);
int32_t ret = 0;
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_P, &(paillierPara.p), &(paillierPara.pLen));
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_Q, &(paillierPara.q), &(paillierPara.qLen));
const BSL_Param *temp = BSL_PARAM_FindConstParam(para, CRYPT_PARAM_PAILLIER_BITS);
if (temp != NULL) {
RETURN_RET_IF_ERR(BSL_PARAM_GetValue(temp, CRYPT_PARAM_PAILLIER_BITS,
BSL_PARAM_TYPE_UINT32, &paillierPara.bits, &bitsLen), ret);
}
return CRYPT_PAILLIER_SetPara(ctx, &paillierPara);
}
#endif
uint32_t CRYPT_PAILLIER_GetBits(const CRYPT_PAILLIER_Ctx *ctx)
{
if (ctx == NULL) {
return 0;
}
if (ctx->para != NULL) {
return ctx->para->bits;
}
if (ctx->prvKey != NULL) {
return BN_Bits(ctx->prvKey->lambda);
}
if (ctx->pubKey != NULL) {
return BN_Bits(ctx->pubKey->n);
}
return 0;
}
CRYPT_PAILLIER_PrvKey *Paillier_NewPrvKey(uint32_t bits)
{
CRYPT_PAILLIER_PrvKey *prvKey = (CRYPT_PAILLIER_PrvKey *)BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_PrvKey));
if (prvKey == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
prvKey->n = BN_Create(bits);
prvKey->lambda = BN_Create(bits);
prvKey->mu = BN_Create(bits);
prvKey->n2 = BN_Create(bits);
if (prvKey->n == NULL || prvKey->lambda == NULL || prvKey->mu == NULL || prvKey->n2 == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
PAILLIER_FREE_PRV_KEY(prvKey);
}
return prvKey;
}
CRYPT_PAILLIER_PubKey *Paillier_NewPubKey(uint32_t bits)
{
CRYPT_PAILLIER_PubKey *pubKey = (CRYPT_PAILLIER_PubKey *)BSL_SAL_Malloc(sizeof(CRYPT_PAILLIER_PubKey));
if (pubKey == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
pubKey->n = BN_Create(bits);
pubKey->g = BN_Create(bits);
pubKey->n2 = BN_Create(bits);
if (pubKey->n == NULL || pubKey->g == NULL || pubKey->n2 == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
PAILLIER_FREE_PUB_KEY(pubKey);
}
return pubKey;
}
static int32_t Paillier_GenPQ(CRYPT_PAILLIER_Para *para, BN_Optimizer *optimizer)
{
uint32_t bits = para->bits;
int32_t ret = BN_GenPrime(para->p, NULL, bits, true, optimizer, NULL);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = BN_GenPrime(para->q, NULL, bits, true, optimizer, NULL);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
static int32_t Paillier_CalcPubKey(CRYPT_PAILLIER_PubKey *pubKey, CRYPT_PAILLIER_Para *para, BN_Optimizer *optimizer)
{
int32_t ret = BN_Mul(pubKey->n, para->p, para->q, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = BN_AddLimb(pubKey->g, pubKey->n, 1); // g = n + 1
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = BN_Sqr(pubKey->n2, pubKey->n, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
static int32_t Paillier_CalcLambda(BN_BigNum *lambda, CRYPT_PAILLIER_Para *para, BN_Optimizer *optimizer)
{
uint32_t bits = para->bits;
BN_BigNum *pMinus1 = BN_Create(bits);
BN_BigNum *qMinus1 = BN_Create(bits);
int32_t ret = CRYPT_MEM_ALLOC_FAIL;
if (pMinus1 == NULL || qMinus1 == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
goto EXIT;
}
ret = BN_SubLimb(pMinus1, para->p, 1);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_SubLimb(qMinus1, para->q, 1);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_Lcm(lambda, pMinus1, qMinus1, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
EXIT:
BN_Destroy(pMinus1);
BN_Destroy(qMinus1);
return ret;
}
static int32_t Paillier_CalcMu(BN_BigNum *mu, const BN_BigNum *lambda, CRYPT_PAILLIER_PubKey *pubKey, uint32_t bits, BN_Optimizer *optimizer)
{
BN_BigNum *x = BN_Create(bits);
BN_BigNum *xMinus1 = BN_Create(bits);
BN_BigNum *Lx = BN_Create(bits);
int32_t ret;
if (x == NULL || xMinus1 == NULL || Lx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
ret = CRYPT_MEM_ALLOC_FAIL;
goto EXIT;
}
ret = BN_ModExp(x, pubKey->g, lambda, pubKey->n2, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_SubLimb(xMinus1, x, 1);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_Div(Lx, NULL, xMinus1, pubKey->n, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_ModInv(mu, Lx, pubKey->n, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
EXIT:
BN_Destroy(x);
BN_Destroy(xMinus1);
BN_Destroy(Lx);
return ret;
}
int32_t Paillier_CalcPrvKey(CRYPT_PAILLIER_Ctx *ctx, BN_Optimizer *optimizer)
{
int32_t ret = Paillier_CalcLambda(ctx->prvKey->lambda, ctx->para, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = Paillier_CalcMu(ctx->prvKey->mu, ctx->prvKey->lambda, ctx->pubKey, ctx->para->bits, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
int32_t CRYPT_PAILLIER_Gen(CRYPT_PAILLIER_Ctx *ctx)
{
if (ctx == NULL || ctx->para == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = CRYPT_MEM_ALLOC_FAIL;
BN_Optimizer *optimizer = NULL;
CRYPT_PAILLIER_Ctx *newCtx = CRYPT_PAILLIER_NewCtx();
if (newCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
newCtx->para = CRYPT_Paillier_DupPara(ctx->para);
if (newCtx->para == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
goto ERR;
}
newCtx->prvKey = Paillier_NewPrvKey(newCtx->para->bits);
newCtx->pubKey = Paillier_NewPubKey(newCtx->para->bits);
optimizer = BN_OptimizerCreate();
if (optimizer == NULL || newCtx->prvKey == NULL || newCtx->pubKey == NULL) {
ret = CRYPT_MEM_ALLOC_FAIL;
BSL_ERR_PUSH_ERROR(ret);
goto ERR;
}
BN_OptimizerSetLibCtx(ctx->libCtx, optimizer);
ret = Paillier_GenPQ(newCtx->para, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto ERR;
}
ret = Paillier_CalcPubKey(newCtx->pubKey, newCtx->para, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto ERR;
}
ret = Paillier_CalcPrvKey(newCtx, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto ERR;
}
GOTO_ERR_IF(BN_Copy(newCtx->prvKey->n, newCtx->pubKey->n), ret);
GOTO_ERR_IF(BN_Copy(newCtx->prvKey->n2, newCtx->pubKey->n2), ret);
PAILLIER_FREE_PARA(ctx->para);
PAILLIER_FREE_PRV_KEY(ctx->prvKey);
PAILLIER_FREE_PUB_KEY(ctx->pubKey);
BSL_SAL_ReferencesFree(&(newCtx->references));
ctx->prvKey = newCtx->prvKey;
ctx->pubKey = newCtx->pubKey;
ctx->para = newCtx->para;
BSL_SAL_FREE(newCtx);
BN_OptimizerDestroy(optimizer);
return ret;
ERR:
CRYPT_PAILLIER_FreeCtx(newCtx);
BN_OptimizerDestroy(optimizer);
return ret;
}
#endif // HITLS_CRYPTO_PAILLIER | 2401_83913325/openHiTLS-examples_2461 | crypto/paillier/src/paillier_keygen.c | C | unknown | 16,825 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PAILLIER
#include "crypt_types.h"
#include "crypt_paillier.h"
#include "crypt_utils.h"
#include "bsl_err_internal.h"
#include "paillier_local.h"
#include "crypt_errno.h"
#include "securec.h"
#include "bsl_sal.h"
#include "crypt_params_key.h"
typedef struct {
BSL_Param *n; /**< Paillier private key parameter marked as n */
BSL_Param *lambda; /**< Paillier private key parameter marked as lambda */
BSL_Param *mu; /**< Paillier private key parameter marked as mu */
BSL_Param *n2; /**< Paillier private key parameter marked as n2 */
} CRYPT_PaillierPrvParam;
typedef struct {
BSL_Param *n; /**< Paillier public key parameter marked as n */
BSL_Param *g; /**< Paillier public key parameter marked as g */
BSL_Param *n2; /**< Paillier public key parameter marked as n2 */
} CRYPT_PaillierPubParam;
#define PARAMISNULL(a) (a == NULL || a->value == NULL)
static int32_t CheckSquare(const BN_BigNum *n2, const BN_BigNum *n, uint32_t bits)
{
BN_BigNum *tmp = BN_Create(bits);
BN_Optimizer *optimizer = BN_OptimizerCreate();
int32_t ret;
if (optimizer == NULL || tmp == NULL) {
ret = CRYPT_MEM_ALLOC_FAIL;
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = BN_Sqr(tmp, n, optimizer);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
if (BN_Cmp(tmp, n2) != 0) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
ret = CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
EXIT:
BN_Destroy(tmp);
BN_OptimizerDestroy(optimizer);
return ret;
}
static int32_t SetPrvPara(const CRYPT_PAILLIER_PrvKey *prvKey, const CRYPT_PaillierPrv *prv)
{
int32_t ret = BN_Bin2Bn(prvKey->n, prv->n, prv->nLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
uint32_t bnBits = BN_Bits(prvKey->n);
if (bnBits > PAILLIER_MAX_MODULUS_BITS || bnBits <= 0) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_KEY_BITS);
return CRYPT_PAILLIER_ERR_KEY_BITS;
}
ret = BN_Bin2Bn(prvKey->lambda, prv->lambda, prv->lambdaLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = BN_Bin2Bn(prvKey->mu, prv->mu, prv->muLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = BN_Bin2Bn(prvKey->n2, prv->n2, prv->n2Len);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = CheckSquare(prvKey->n2, prvKey->n, prv->n2Len * 8);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
if (BN_IsZero(prvKey->mu) || BN_IsOne(prvKey->mu)) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
return CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
return ret;
}
static int32_t SetPrvBasicCheck(const CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PaillierPrv *prv)
{
if (ctx == NULL || prv == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (prv->n == NULL || prv->lambda == NULL || prv->mu == NULL || prv->n2 == NULL ||
prv->lambdaLen == 0 || prv->muLen == 0 || prv->nLen == 0 || prv->n2Len == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
return CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
return CRYPT_SUCCESS;
}
int32_t CRYPT_PAILLIER_SetPrvKey(CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PaillierPrv *prv)
{
int32_t ret = SetPrvBasicCheck(ctx, prv);
if (ret != CRYPT_SUCCESS) {
return ret;
}
CRYPT_PAILLIER_Ctx *newCtx = CRYPT_PAILLIER_NewCtx();
if (newCtx == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
newCtx->prvKey = Paillier_NewPrvKey(prv->lambdaLen * 8); // Bit length is obtained by multiplying byte length by 8.
if (newCtx->prvKey == NULL) {
ret = CRYPT_MEM_ALLOC_FAIL;
BSL_ERR_PUSH_ERROR(ret);
goto ERR;
}
ret = SetPrvPara(newCtx->prvKey, prv);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto ERR;
}
PAILLIER_FREE_PRV_KEY(ctx->prvKey);
ctx->prvKey = newCtx->prvKey;
BSL_SAL_ReferencesFree(&(newCtx->references));
BSL_SAL_FREE(newCtx);
return ret;
ERR:
CRYPT_PAILLIER_FreeCtx(newCtx);
return ret;
}
static int32_t SetPubBasicCheck(const CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PaillierPub *pub)
{
if (ctx == NULL || pub == NULL || pub->n == NULL || pub->g == NULL || pub->n2 == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
return CRYPT_SUCCESS;
}
int32_t CRYPT_PAILLIER_SetPubKey(CRYPT_PAILLIER_Ctx *ctx, const CRYPT_PaillierPub *pub)
{
int32_t ret = SetPubBasicCheck(ctx, pub);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
CRYPT_PAILLIER_PubKey *newPub = NULL;
/* Bit length is obtained by multiplying byte length by 8. */
newPub = Paillier_NewPubKey(pub->nLen * 8);
if (newPub == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
GOTO_ERR_IF(BN_Bin2Bn(newPub->n, pub->n, pub->nLen), ret);
uint32_t bnBits = BN_Bits(newPub->n);
if (bnBits > PAILLIER_MAX_MODULUS_BITS || bnBits <= 0) {
ret = CRYPT_PAILLIER_ERR_KEY_BITS;
BSL_ERR_PUSH_ERROR(ret);
goto ERR;
}
GOTO_ERR_IF(BN_Bin2Bn(newPub->g, pub->g, pub->gLen), ret);
GOTO_ERR_IF(BN_Bin2Bn(newPub->n2, pub->n2, pub->n2Len), ret);
GOTO_ERR_IF(CheckSquare(newPub->n2, newPub->n, pub->nLen * 8), ret);
PAILLIER_FREE_PUB_KEY(ctx->pubKey);
ctx->pubKey = newPub;
return ret;
ERR:
PAILLIER_FREE_PUB_KEY(newPub);
return ret;
}
int32_t CRYPT_PAILLIER_GetPrvKey(const CRYPT_PAILLIER_Ctx *ctx, CRYPT_PaillierPrv *prv)
{
if (ctx == NULL || ctx->prvKey == NULL || prv == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (prv->lambda == NULL || prv->mu == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PAILLIER_ERR_INPUT_VALUE);
return CRYPT_PAILLIER_ERR_INPUT_VALUE;
}
int32_t ret = 0;
GOTO_ERR_IF(BN_Bn2Bin(ctx->prvKey->lambda, prv->lambda, &prv->lambdaLen), ret);
GOTO_ERR_IF(BN_Bn2Bin(ctx->prvKey->mu, prv->mu, &prv->muLen), ret);
if (prv->n != NULL) {
GOTO_ERR_IF(BN_Bn2Bin(ctx->prvKey->n, prv->n, &prv->nLen), ret);
}
if (prv->n2 != NULL) {
GOTO_ERR_IF(BN_Bn2Bin(ctx->prvKey->n2, prv->n2, &prv->n2Len), ret);
}
return CRYPT_SUCCESS;
ERR:
BSL_SAL_CleanseData(prv->lambda, prv->lambdaLen);
BSL_SAL_CleanseData(prv->mu, prv->muLen);
BSL_SAL_CleanseData(prv->n, prv->nLen);
BSL_SAL_CleanseData(prv->n2, prv->n2Len);
prv->lambdaLen = 0;
prv->muLen = 0;
prv->nLen = 0;
prv->n2Len = 0;
return ret;
}
int32_t CRYPT_PAILLIER_GetPubKey(const CRYPT_PAILLIER_Ctx *ctx, CRYPT_PaillierPub *pub)
{
if (ctx == NULL || ctx->pubKey == NULL || pub == NULL ||
pub->n == NULL || pub->g == NULL || pub->n2 == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = 0;
GOTO_ERR_IF(BN_Bn2Bin(ctx->pubKey->g, pub->g, &pub->gLen), ret);
GOTO_ERR_IF(BN_Bn2Bin(ctx->pubKey->n, pub->n, &pub->nLen), ret);
GOTO_ERR_IF(BN_Bn2Bin(ctx->pubKey->n2, pub->n2, &pub->n2Len), ret);
return CRYPT_SUCCESS;
ERR:
BSL_SAL_CleanseData(pub->g, pub->gLen);
BSL_SAL_CleanseData(pub->n, pub->nLen);
BSL_SAL_CleanseData(pub->n2, pub->n2Len);
pub->gLen = 0;
pub->nLen = 0;
pub->n2Len = 0;
return ret;
}
#ifdef HITLS_BSL_PARAMS
int32_t CRYPT_PAILLIER_SetPrvKeyEx(CRYPT_PAILLIER_Ctx *ctx, const BSL_Param *para)
{
if (para == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
CRYPT_PaillierPrv prv = {0};
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_N, &prv.n, &prv.nLen);
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_LAMBDA, &prv.lambda, &prv.lambdaLen);
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_MU, &prv.mu, &prv.muLen);
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_N2, &prv.n2, &prv.n2Len);
return CRYPT_PAILLIER_SetPrvKey(ctx, &prv);
}
int32_t CRYPT_PAILLIER_SetPubKeyEx(CRYPT_PAILLIER_Ctx *ctx, const BSL_Param *para)
{
if (para == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
CRYPT_PaillierPub pub = {0};
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_N, &pub.n, &pub.nLen);
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_G, &pub.g, &pub.gLen);
(void)GetConstParamValue(para, CRYPT_PARAM_PAILLIER_N2, &pub.n2, &pub.n2Len);
return CRYPT_PAILLIER_SetPubKey(ctx, &pub);
}
int32_t CRYPT_PAILLIER_GetPrvKeyEx(const CRYPT_PAILLIER_Ctx *ctx, BSL_Param *para)
{
if (para == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
CRYPT_PaillierPrv prv = {0};
BSL_Param *paramN = GetParamValue(para, CRYPT_PARAM_PAILLIER_N, &prv.n, &(prv.nLen));
BSL_Param *paramLambda = GetParamValue(para, CRYPT_PARAM_PAILLIER_LAMBDA, &prv.lambda, &(prv.lambdaLen));
BSL_Param *paramMu = GetParamValue(para, CRYPT_PARAM_PAILLIER_MU, &prv.mu, &(prv.muLen));
BSL_Param *paramN2 = GetParamValue(para, CRYPT_PARAM_PAILLIER_N2, &prv.n2, &(prv.n2Len));
int32_t ret = CRYPT_PAILLIER_GetPrvKey(ctx, &prv);
if (ret != CRYPT_SUCCESS) {
return ret;
}
paramLambda->useLen = prv.lambdaLen;
paramMu->useLen = prv.muLen;
if (paramN != NULL) {
paramN->useLen = prv.nLen;
}
if (paramN2 != NULL) {
paramN2->useLen = prv.n2Len;
}
return CRYPT_SUCCESS;
}
int32_t CRYPT_PAILLIER_GetPubKeyEx(const CRYPT_PAILLIER_Ctx *ctx, BSL_Param *para)
{
if (para == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
CRYPT_PaillierPub pub = {0};
BSL_Param *paramN = GetParamValue(para, CRYPT_PARAM_PAILLIER_N, &pub.n, &(pub.nLen));
BSL_Param *paramG = GetParamValue(para, CRYPT_PARAM_PAILLIER_G, &pub.g, &(pub.gLen));
BSL_Param *paramN2 = GetParamValue(para, CRYPT_PARAM_PAILLIER_N2, &pub.n2, &(pub.n2Len));
int32_t ret = CRYPT_PAILLIER_GetPubKey(ctx, &pub);
if (ret != CRYPT_SUCCESS) {
return ret;
}
paramN->useLen = pub.nLen;
paramG->useLen = pub.gLen;
paramN2->useLen = pub.n2Len;
return CRYPT_SUCCESS;
}
#endif
int32_t CRYPT_PAILLIER_GetSecBits(const CRYPT_PAILLIER_Ctx *ctx)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return 0;
}
int32_t bits = (int32_t)CRYPT_PAILLIER_GetBits(ctx);
return BN_SecBits(bits, -1);
}
#endif /* HITLS_CRYPTO_PAILLIER */ | 2401_83913325/openHiTLS-examples_2461 | crypto/paillier/src/paillier_keyop.c | C | unknown | 11,292 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef PAILLIER_LOCAL_H
#define PAILLIER_LOCAL_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PAILLIER
#include "crypt_paillier.h"
#include "crypt_bn.h"
#include "crypt_local_types.h"
#include "crypt_types.h"
#include "sal_atomic.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cpluscplus */
typedef struct {
BN_BigNum *n; // modulo Value - converted.Not in char
BN_BigNum *g; // modulo Value -converted.Not in char
BN_BigNum *n2; // square of n
} CRYPT_PAILLIER_PubKey;
typedef struct {
BN_BigNum *n; // pub key n needed for decryption
BN_BigNum *lambda; // modulo Value - converted.Not in char
BN_BigNum *mu; // modulo Value -converted.Not in char
BN_BigNum *n2; // pub key n2 needed for decryption
} CRYPT_PAILLIER_PrvKey;
struct PAILLIER_Para {
BN_BigNum *p; // prime factor p
BN_BigNum *q; // prime factor q
uint32_t bits; // length in bits of modulus
};
struct PAILLIER_Ctx {
CRYPT_PAILLIER_PubKey *pubKey;
CRYPT_PAILLIER_PrvKey *prvKey;
CRYPT_PAILLIER_Para *para;
BSL_SAL_RefCount references;
void *libCtx;
};
CRYPT_PAILLIER_PrvKey *Paillier_NewPrvKey(uint32_t bits);
CRYPT_PAILLIER_PubKey *Paillier_NewPubKey(uint32_t bits);
void PAILLIER_FreePrvKey(CRYPT_PAILLIER_PrvKey *prvKey);
void PAILLIER_FreePubKey(CRYPT_PAILLIER_PubKey *pubKey);
CRYPT_PAILLIER_Para *CRYPT_Paillier_DupPara(const CRYPT_PAILLIER_Para *para);
#define PAILLIER_FREE_PRV_KEY(prvKey_) \
do { \
PAILLIER_FreePrvKey((prvKey_)); \
(prvKey_) = NULL; \
} while (0)
#define PAILLIER_FREE_PUB_KEY(pubKey_) \
do { \
PAILLIER_FreePubKey((pubKey_)); \
(pubKey_) = NULL; \
} while (0)
#define PAILLIER_FREE_PARA(para_) \
do { \
CRYPT_PAILLIER_FreePara((para_)); \
(para_) = NULL; \
} while (0)
#ifdef __cplusplus
}
#endif
#endif // HITLS_CRYPTO_PAILLIER
#endif // PAILLIER_LOCAL_H | 2401_83913325/openHiTLS-examples_2461 | crypto/paillier/src/paillier_local.h | C | unknown | 2,729 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CRYPT_PBKDF2_H
#define CRYPT_PBKDF2_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PBKDF2
#include <stdint.h>
#include "crypt_local_types.h"
#include "bsl_params.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
typedef struct CryptPbkdf2Ctx CRYPT_PBKDF2_Ctx;
/**
* @ingroup PBKDF2
* @brief Generate PBKDF2 context.
*
* @retval Success: PBKDF2 ctx.
* Fails: NULL.
*/
CRYPT_PBKDF2_Ctx* CRYPT_PBKDF2_NewCtx(void);
/**
* @ingroup PBKDF2
* @brief Generate PBKDF2 context.
*
* @param libCtx [in] Library context.
*
* @retval Success: PBKDF2 ctx.
* Fails: NULL.
*/
CRYPT_PBKDF2_Ctx *CRYPT_PBKDF2_NewCtxEx(void *libCtx);
/**
* @ingroup PBKDF2
* @brief Set parameters for the PBKDF2 context.
*
* @param ctx [in, out] Pointer to the PBKDF2 context.
* @param param [in] Either a MAC algorithm ID, a salt, a password, or an iteration count.
*
* @retval Success: CRYPT_SUCCESS
* For other error codes, see crypt_errno.h.
*/
int32_t CRYPT_PBKDF2_SetParam(CRYPT_PBKDF2_Ctx *ctx, const BSL_Param *param);
/**
* @ingroup PBKDF2
* @brief Obtain the derived key based on the passed PBKDF2 context..
*
* @param ctx [in, out] Pointer to the PBKDF2 context.
* @param out [out] Derived key buffer.
* @param out [out] Derived key buffer size.
*
* @retval Success: CRYPT_SUCCESS
* For other error codes, see crypt_errno.h.
*/
int32_t CRYPT_PBKDF2_Derive(CRYPT_PBKDF2_Ctx *ctx, uint8_t *out, uint32_t len);
/**
* @ingroup PBKDF2
* @brief PBKDF2 deinitialization API
*
* @param ctx [in, out] Pointer to the PBKDF2 context.
*
* @retval #CRYPT_SUCCESS Deinitialization succeeded.
* @retval #CRYPT_NULL_INPUT Pointer ctx is NULL
*/
int32_t CRYPT_PBKDF2_Deinit(CRYPT_PBKDF2_Ctx *ctx);
/**
* @ingroup PBKDF2
* @brief free PBKDF2 context.
*
* @param ctx [IN] PBKDF2 handle
*/
void CRYPT_PBKDF2_FreeCtx(CRYPT_PBKDF2_Ctx *ctx);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // HITLS_CRYPTO_PBKDF2
#endif // CRYPT_PBKDF2_H
| 2401_83913325/openHiTLS-examples_2461 | crypto/pbkdf2/include/crypt_pbkdf2.h | C | unknown | 2,561 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PBKDF2
#include <stdint.h>
#include "securec.h"
#include "bsl_err_internal.h"
#include "bsl_sal.h"
#include "crypt_local_types.h"
#include "crypt_errno.h"
#include "crypt_utils.h"
#include "crypt_algid.h"
#include "eal_mac_local.h"
#include "crypt_ealinit.h"
#include "pbkdf2_local.h"
#include "bsl_params.h"
#include "crypt_params_key.h"
#include "crypt_pbkdf2.h"
#define PBKDF2_MAX_BLOCKSIZE 64
#define PBKDF2_MAX_KEYLEN 0xFFFFFFFF
static const uint32_t PBKDF_ID_LIST[] = {
CRYPT_MAC_HMAC_MD5,
CRYPT_MAC_HMAC_SHA1,
CRYPT_MAC_HMAC_SHA224,
CRYPT_MAC_HMAC_SHA256,
CRYPT_MAC_HMAC_SHA384,
CRYPT_MAC_HMAC_SHA512,
CRYPT_MAC_HMAC_SM3,
CRYPT_MAC_HMAC_SHA3_224,
CRYPT_MAC_HMAC_SHA3_256,
CRYPT_MAC_HMAC_SHA3_384,
CRYPT_MAC_HMAC_SHA3_512,
};
struct CryptPbkdf2Ctx {
CRYPT_MAC_AlgId macId;
EAL_MacMethod macMeth;
uint32_t mdSize;
void *macCtx;
uint8_t *password;
uint32_t passLen;
uint8_t *salt;
uint32_t saltLen;
uint32_t iterCnt;
#ifdef HITLS_CRYPTO_PROVIDER
void *libCtx;
#endif
bool hasGetMdSize;
};
bool CRYPT_PBKDF2_IsValidAlgId(CRYPT_MAC_AlgId id)
{
return ParamIdIsValid(id, PBKDF_ID_LIST, sizeof(PBKDF_ID_LIST) / sizeof(PBKDF_ID_LIST[0]));
}
int32_t CRYPT_PBKDF2_U1(const CRYPT_PBKDF2_Ctx *pCtx, uint32_t blockCount, uint8_t *u, uint32_t *blockSize)
{
int32_t ret;
const EAL_MacMethod *macMeth = &pCtx->macMeth;
void *macCtx = pCtx->macCtx;
(void)macMeth->reinit(macCtx);
if ((ret = macMeth->update(macCtx, pCtx->salt, pCtx->saltLen)) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
/* processing the big endian */
uint32_t blockCnt = CRYPT_HTONL(blockCount);
if ((ret = macMeth->update(macCtx, (uint8_t *)&blockCnt, sizeof(blockCnt))) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
if ((ret = macMeth->final(macCtx, u, blockSize)) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
return CRYPT_SUCCESS;
}
int32_t CRYPT_PBKDF2_Un(const CRYPT_PBKDF2_Ctx *pCtx, uint8_t *u, uint32_t *blockSize, uint8_t *t, uint32_t tLen)
{
int32_t ret;
const EAL_MacMethod *macMeth = &pCtx->macMeth;
void *macCtx = pCtx->macCtx;
macMeth->reinit(macCtx);
if ((ret = macMeth->update(macCtx, u, *blockSize)) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
if ((ret = macMeth->final(macCtx, u, blockSize)) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
DATA_XOR(t, u, t, tLen);
return CRYPT_SUCCESS;
}
int32_t CRYPT_PBKDF2_CalcT(const CRYPT_PBKDF2_Ctx *pCtx, uint32_t blockCount, uint8_t *t, uint32_t *tlen)
{
uint8_t u[PBKDF2_MAX_BLOCKSIZE] = {0};
uint8_t tmpT[PBKDF2_MAX_BLOCKSIZE] = {0};
uint32_t blockSize = PBKDF2_MAX_BLOCKSIZE;
int32_t ret;
uint32_t iterCnt = pCtx->iterCnt;
/* U1 = PRF(Password, Salt + INT_32_BE(i))
tmpT = U1 */
ret = CRYPT_PBKDF2_U1(pCtx, blockCount, u, &blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
(void)memcpy_s(tmpT, PBKDF2_MAX_BLOCKSIZE, u, blockSize);
for (uint32_t un = 1; un < iterCnt; un++) {
/* t = t ^ Un */
ret = CRYPT_PBKDF2_Un(pCtx, u, &blockSize, tmpT, blockSize);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
}
uint32_t len = (*tlen > blockSize) ? blockSize : (*tlen);
(void)memcpy_s(t, *tlen, tmpT, len);
*tlen = len;
BSL_SAL_CleanseData(u, PBKDF2_MAX_BLOCKSIZE);
BSL_SAL_CleanseData(tmpT, PBKDF2_MAX_BLOCKSIZE);
return CRYPT_SUCCESS;
}
int32_t CRYPT_PBKDF2_GenDk(const CRYPT_PBKDF2_Ctx *pCtx, uint8_t *dk, uint32_t dkLen)
{
uint32_t curLen;
uint8_t *t = dk;
uint32_t tlen;
uint32_t i;
int32_t ret;
ret = pCtx->macMeth.init(pCtx->macCtx, pCtx->password, pCtx->passLen, NULL);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
/* DK = T1 + T2 + ⋯ + Tdklen/hlen */
for (i = 1, curLen = dkLen; curLen > 0; i++) {
tlen = curLen;
ret = CRYPT_PBKDF2_CalcT(pCtx, i, t, &tlen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
curLen -= tlen;
t += tlen;
}
return CRYPT_SUCCESS;
}
int32_t CRYPT_PBKDF2_HMAC(void *libCtx, const EAL_MacMethod *macMeth, CRYPT_MAC_AlgId macId, const EAL_MdMethod *mdMeth,
const uint8_t *key, uint32_t keyLen,
const uint8_t *salt, uint32_t saltLen,
uint32_t iterCnt, uint8_t *out, uint32_t len)
{
int32_t ret;
CRYPT_PBKDF2_Ctx pCtx;
if (macMeth == NULL || mdMeth == NULL || out == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (key == NULL && keyLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
// add keyLen limit based on rfc2898
if (mdMeth->mdSize == 0 || (keyLen / mdMeth->mdSize) >= PBKDF2_MAX_KEYLEN) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_PARAM_ERROR);
return CRYPT_PBKDF2_PARAM_ERROR;
}
if (salt == NULL && saltLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if ((len == 0) || (iterCnt == 0)) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_PARAM_ERROR);
return CRYPT_PBKDF2_PARAM_ERROR;
}
void *macCtx = macMeth->newCtx(libCtx, macId);
if (macCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
pCtx.macMeth = *macMeth;
pCtx.macCtx = macCtx;
pCtx.password = (uint8_t *)(uintptr_t)key;
pCtx.passLen = keyLen;
pCtx.salt = (uint8_t *)(uintptr_t)salt;
pCtx.saltLen = saltLen;
pCtx.iterCnt = iterCnt;
ret = CRYPT_PBKDF2_GenDk(&pCtx, out, len);
macMeth->deinit(macCtx);
macMeth->freeCtx(macCtx);
macCtx = NULL;
return ret;
}
CRYPT_PBKDF2_Ctx *CRYPT_PBKDF2_NewCtx(void)
{
CRYPT_PBKDF2_Ctx *ctx = BSL_SAL_Calloc(1, sizeof(CRYPT_PBKDF2_Ctx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
return ctx;
}
CRYPT_PBKDF2_Ctx *CRYPT_PBKDF2_NewCtxEx(void *libCtx)
{
(void)libCtx;
CRYPT_PBKDF2_Ctx *ctx = CRYPT_PBKDF2_NewCtx();
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
#ifdef HITLS_CRYPTO_PROVIDER
ctx->libCtx = libCtx;
#endif
return ctx;
}
int32_t CRYPT_PBKDF2_SetMacMethod(CRYPT_PBKDF2_Ctx *ctx, const CRYPT_MAC_AlgId id)
{
#ifdef HITLS_CRYPTO_ASM_CHECK
if (CRYPT_ASMCAP_Mac(id) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
}
#endif
if (!CRYPT_PBKDF2_IsValidAlgId(id)) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_PARAM_ERROR);
return CRYPT_PBKDF2_PARAM_ERROR;
}
// free the old macCtx
if (ctx->macCtx != NULL) {
if (ctx->macMeth.freeCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_ERR_MAC_METH);
return CRYPT_PBKDF2_ERR_MAC_METH;
}
ctx->macMeth.freeCtx(ctx->macCtx);
ctx->macCtx = NULL;
(void)memset_s(&ctx->macMeth, sizeof(EAL_MacMethod), 0, sizeof(EAL_MacMethod));
}
EAL_MacMethod *macMeth = EAL_MacFindMethod(id, &ctx->macMeth);
if (macMeth == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ERR_METH_NULL_MEMBER);
return CRYPT_EAL_ERR_METH_NULL_MEMBER;
}
if (macMeth->newCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_ERR_MAC_METH);
return CRYPT_PBKDF2_ERR_MAC_METH;
}
#ifdef HITLS_CRYPTO_PROVIDER
ctx->macCtx = macMeth->newCtx(ctx->libCtx, id);
#else
ctx->macCtx = macMeth->newCtx(NULL, id);
#endif
if (ctx->macCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
ctx->macId = id;
return CRYPT_SUCCESS;
}
int32_t CRYPT_PBKDF2_SetPassWord(CRYPT_PBKDF2_Ctx *ctx, const uint8_t *password, uint32_t passLen)
{
if (password == NULL && passLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
BSL_SAL_ClearFree(ctx->password, ctx->passLen);
ctx->password = BSL_SAL_Dump(password, passLen);
if (ctx->password == NULL && passLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
ctx->passLen = passLen;
return CRYPT_SUCCESS;
}
int32_t CRYPT_PBKDF2_SetSalt(CRYPT_PBKDF2_Ctx *ctx, const uint8_t *salt, uint32_t saltLen)
{
if (salt == NULL && saltLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
BSL_SAL_FREE(ctx->salt);
ctx->salt = BSL_SAL_Dump(salt, saltLen);
if (ctx->salt == NULL && saltLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
ctx->saltLen = saltLen;
return CRYPT_SUCCESS;
}
int32_t CRYPT_PBKDF2_SetCnt(CRYPT_PBKDF2_Ctx *ctx, const uint32_t iterCnt)
{
if (iterCnt == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_PARAM_ERROR);
return CRYPT_PBKDF2_PARAM_ERROR;
}
ctx->iterCnt = iterCnt;
return CRYPT_SUCCESS;
}
static int32_t Pbkdf2GetMdSize(CRYPT_PBKDF2_Ctx *ctx, const char *mdAttr)
{
if (ctx->hasGetMdSize) {
return CRYPT_SUCCESS;
}
void *libCtx = NULL;
#ifdef HITLS_CRYPTO_PROVIDER
libCtx = ctx->libCtx;
#endif
EAL_MdMethod mdMeth = {0};
EAL_MacDepMethod depMeth = {.method = {.md = &mdMeth}};
int32_t ret = EAL_MacFindDepMethod(ctx->macId, libCtx, mdAttr, &depMeth, NULL, true);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ctx->mdSize = mdMeth.mdSize;
ctx->hasGetMdSize = true;
return CRYPT_SUCCESS;
}
#ifdef HITLS_CRYPTO_PROVIDER
static int32_t CRYPT_PBKDF2_SetMdAttr(CRYPT_PBKDF2_Ctx *ctx, const char *mdAttr, uint32_t valLen)
{
if (mdAttr == NULL || valLen == 0) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_PARAM_ERROR);
return CRYPT_PBKDF2_PARAM_ERROR;
}
if (ctx->macCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_ERR_MAC_ID_NOT_SET);
return CRYPT_PBKDF2_ERR_MAC_ID_NOT_SET;
}
// Set mdAttr for macCtx
if (ctx->macMeth.setParam == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_ERR_MAC_METH);
return CRYPT_PBKDF2_ERR_MAC_METH;
}
BSL_Param param[] = {
{.key = CRYPT_PARAM_MD_ATTR, .valueType = BSL_PARAM_TYPE_UTF8_STR,
.value = (void *)(uintptr_t)mdAttr, .valueLen = valLen, .useLen = 0},
BSL_PARAM_END
};
int32_t ret = ctx->macMeth.setParam(ctx->macCtx, param);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
return Pbkdf2GetMdSize(ctx, mdAttr);
}
#endif
int32_t CRYPT_PBKDF2_SetParam(CRYPT_PBKDF2_Ctx *ctx, const BSL_Param *param)
{
uint32_t val = 0;
uint32_t len = 0;
const BSL_Param *temp = NULL;
int32_t ret = CRYPT_PBKDF2_PARAM_ERROR;
if (ctx == NULL || param == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_KDF_MAC_ID)) != NULL) {
len = sizeof(val);
GOTO_ERR_IF(BSL_PARAM_GetValue(temp, CRYPT_PARAM_KDF_MAC_ID,
BSL_PARAM_TYPE_UINT32, &val, &len), ret);
GOTO_ERR_IF(CRYPT_PBKDF2_SetMacMethod(ctx, val), ret);
}
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_KDF_PASSWORD)) != NULL) {
GOTO_ERR_IF(CRYPT_PBKDF2_SetPassWord(ctx, temp->value, temp->valueLen), ret);
}
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_KDF_SALT)) != NULL) {
GOTO_ERR_IF(CRYPT_PBKDF2_SetSalt(ctx, temp->value, temp->valueLen), ret);
}
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_KDF_ITER)) != NULL) {
len = sizeof(val);
GOTO_ERR_IF(BSL_PARAM_GetValue(temp, CRYPT_PARAM_KDF_ITER,
BSL_PARAM_TYPE_UINT32, &val, &len), ret);
GOTO_ERR_IF(CRYPT_PBKDF2_SetCnt(ctx, val), ret);
}
#ifdef HITLS_CRYPTO_PROVIDER
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_MD_ATTR)) != NULL) {
GOTO_ERR_IF(CRYPT_PBKDF2_SetMdAttr(ctx, temp->value, temp->valueLen), ret);
}
#endif
ERR:
return ret;
}
int32_t CRYPT_PBKDF2_Derive(CRYPT_PBKDF2_Ctx *ctx, uint8_t *out, uint32_t len)
{
if (ctx == NULL || out == NULL || ctx->macCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ctx->macMeth.deinit == NULL || ctx->macMeth.freeCtx == NULL || ctx->macMeth.init == NULL ||
ctx->macMeth.reinit == NULL || ctx->macMeth.update == NULL || ctx->macMeth.final == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_ERR_MAC_METH);
return CRYPT_PBKDF2_ERR_MAC_METH;
}
if (ctx->password == NULL && ctx->passLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = Pbkdf2GetMdSize(ctx, NULL);
if (ret != CRYPT_SUCCESS) {
return ret;
}
// add keyLen limit based on rfc2898
if (ctx->mdSize == 0 || (ctx->passLen / ctx->mdSize) >= PBKDF2_MAX_KEYLEN) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_PARAM_ERROR);
return CRYPT_PBKDF2_PARAM_ERROR;
}
if (ctx->salt == NULL && ctx->saltLen > 0) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if ((len == 0) || (ctx->iterCnt == 0)) {
BSL_ERR_PUSH_ERROR(CRYPT_PBKDF2_PARAM_ERROR);
return CRYPT_PBKDF2_PARAM_ERROR;
}
return CRYPT_PBKDF2_GenDk(ctx, out, len);
}
int32_t CRYPT_PBKDF2_Deinit(CRYPT_PBKDF2_Ctx *ctx)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ctx->macMeth.freeCtx != NULL) {
ctx->macMeth.freeCtx(ctx->macCtx);
ctx->macCtx = NULL;
}
BSL_SAL_ClearFree((void *)ctx->password, ctx->passLen);
BSL_SAL_FREE(ctx->salt);
(void)memset_s(ctx, sizeof(CRYPT_PBKDF2_Ctx), 0, sizeof(CRYPT_PBKDF2_Ctx));
return CRYPT_SUCCESS;
}
void CRYPT_PBKDF2_FreeCtx(CRYPT_PBKDF2_Ctx *ctx)
{
if (ctx == NULL) {
return;
}
if (ctx->macMeth.freeCtx != NULL) {
ctx->macMeth.freeCtx(ctx->macCtx);
}
BSL_SAL_ClearFree((void *)ctx->password, ctx->passLen);
BSL_SAL_FREE(ctx->salt);
BSL_SAL_Free(ctx);
}
#endif // HITLS_CRYPTO_PBKDF2
| 2401_83913325/openHiTLS-examples_2461 | crypto/pbkdf2/src/pbkdf2.c | C | unknown | 15,120 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef PBKDF2_LOCAL_H
#define PBKDF2_LOCAL_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PBKDF2
#include <stdint.h>
#include "crypt_local_types.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
/**
* @brief PBKDF Password-based key derivation function
*
* @param libCtx [IN] Library context
* @param macMeth [IN] Pointer to the HMAC algorithm method
* @param mdMeth [IN] MD algorithm method pointer
* @param key [IN] Password, a string entered by the user.
* @param keyLen [IN] Password length, which can be any length, including 0.
* @param salt [IN] Salt value, a string entered by the user.
* @param saltLen [IN] Salt value length, which can be any length, including 0.
* @param iterCnt [IN] Iteration times. The value can be any positive integer that is not 0.
* The value can be 1000 in special performance cases. The default value is 10000,
* 10000000 is recommended in cases where performance is insensitive or security requirements are high.
* @param out [OUT] Derived key.
* @param len [IN] Length of the derived key. The value range is [1, 0xFFFFFFFF].
*
* @return Success: CRYPT_SUCCESS
* For other error codes, see crypt_errno.h
*/
int32_t CRYPT_PBKDF2_HMAC(void *libCtx, const EAL_MacMethod *macMeth, CRYPT_MAC_AlgId macId, const EAL_MdMethod *mdMeth,
const uint8_t *key, uint32_t keyLen,
const uint8_t *salt, uint32_t saltLen,
uint32_t iterCnt, uint8_t *out, uint32_t len);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // HITLS_CRYPTO_PBKDF2
#endif // PBKDF2_LOCAL_H
| 2401_83913325/openHiTLS-examples_2461 | crypto/pbkdf2/src/pbkdf2_local.h | C | unknown | 2,115 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/**
* @defgroup crypt_eal_provider
* @ingroup crypt
* @brief default provider impl
*/
#ifndef CRYPT_EAL_DEFAULT_PROVIDERIMPL_H
#define CRYPT_EAL_DEFAULT_PROVIDERIMPL_H
#ifdef HITLS_CRYPTO_PROVIDER
#include "crypt_eal_implprovider.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
#ifdef HITLS_CRYPTO_MD
#ifdef HITLS_CRYPTO_MD5
extern const CRYPT_EAL_Func g_defEalMdMd5[];
#endif // HITLS_CRYPTO_MD5
#ifdef HITLS_CRYPTO_SHA1
extern const CRYPT_EAL_Func g_defEalMdSha1[];
#endif // HITLS_CRYPTO_SHA1
#ifdef HITLS_CRYPTO_SHA224
extern const CRYPT_EAL_Func g_defEalMdSha224[];
#endif // HITLS_CRYPTO_SHA224
#ifdef HITLS_CRYPTO_SHA256
extern const CRYPT_EAL_Func g_defEalMdSha256[];
#endif // HITLS_CRYPTO_SHA256
#ifdef HITLS_CRYPTO_SHA384
extern const CRYPT_EAL_Func g_defEalMdSha384[];
#endif // HITLS_CRYPTO_SHA384
#ifdef HITLS_CRYPTO_SHA512
extern const CRYPT_EAL_Func g_defEalMdSha512[];
#endif // HITLS_CRYPTO_SHA512
#ifdef HITLS_CRYPTO_SHA3
extern const CRYPT_EAL_Func g_defEalMdSha3224[];
extern const CRYPT_EAL_Func g_defEalMdSha3256[];
extern const CRYPT_EAL_Func g_defEalMdSha3384[];
extern const CRYPT_EAL_Func g_defEalMdSha3512[];
extern const CRYPT_EAL_Func g_defEalMdShake512[];
extern const CRYPT_EAL_Func g_defEalMdShake128[];
extern const CRYPT_EAL_Func g_defEalMdShake256[];
#endif // HITLS_CRYPTO_SHA3
#ifdef HITLS_CRYPTO_SM3
extern const CRYPT_EAL_Func g_defEalMdSm3[];
#endif // HITLS_CRYPTO_SM3
#endif // HITLS_CRYPTO_MD
#ifdef HITLS_CRYPTO_MAC
#ifdef HITLS_CRYPTO_HMAC
extern const CRYPT_EAL_Func g_defEalMacHmac[];
#endif
#ifdef HITLS_CRYPTO_CMAC
extern const CRYPT_EAL_Func g_defEalMacCmac[];
#endif
#ifdef HITLS_CRYPTO_CBC_MAC
extern const CRYPT_EAL_Func g_defEalMacCbcMac[];
#endif
#ifdef HITLS_CRYPTO_GMAC
extern const CRYPT_EAL_Func g_defEalMacGmac[];
#endif
#ifdef HITLS_CRYPTO_SIPHASH
extern const CRYPT_EAL_Func g_defEalMacSiphash[];
#endif
#endif // HITLS_CRYPTO_MAC
#ifdef HITLS_CRYPTO_KDF
#ifdef HITLS_CRYPTO_SCRYPT
extern const CRYPT_EAL_Func g_defEalKdfScrypt[];
#endif
#ifdef HITLS_CRYPTO_PBKDF2
extern const CRYPT_EAL_Func g_defEalKdfPBKdf2[];
#endif
#ifdef HITLS_CRYPTO_KDFTLS12
extern const CRYPT_EAL_Func g_defEalKdfKdfTLS12[];
#endif
#ifdef HITLS_CRYPTO_HKDF
extern const CRYPT_EAL_Func g_defEalKdfHkdf[];
#endif
#endif // HITLS_CRYPTO_KDF
#ifdef HITLS_CRYPTO_CIPHER
#ifdef HITLS_CRYPTO_CBC
extern const CRYPT_EAL_Func g_defEalCbc[];
#endif
#ifdef HITLS_CRYPTO_CCM
extern const CRYPT_EAL_Func g_defEalCcm[];
#endif
#ifdef HITLS_CRYPTO_CFB
extern const CRYPT_EAL_Func g_defEalCfb[];
#endif
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
extern const CRYPT_EAL_Func g_defEalChaCha[];
#endif
#ifdef HITLS_CRYPTO_CTR
extern const CRYPT_EAL_Func g_defEalCtr[];
#endif
#ifdef HITLS_CRYPTO_ECB
extern const CRYPT_EAL_Func g_defEalEcb[];
#endif
#ifdef HITLS_CRYPTO_GCM
extern const CRYPT_EAL_Func g_defEalGcm[];
#endif
#ifdef HITLS_CRYPTO_OFB
extern const CRYPT_EAL_Func g_defEalOfb[];
#endif
#ifdef HITLS_CRYPTO_XTS
extern const CRYPT_EAL_Func g_defEalXts[];
#endif
#endif // HITLS_CRYPTO_CIPHER
#ifdef HITLS_CRYPTO_DRBG
extern const CRYPT_EAL_Func g_defEalRand[];
#endif // HITLS_CRYPTO_DRBG
#ifdef HITLS_CRYPTO_PKEY
#ifdef HITLS_CRYPTO_DSA
extern const CRYPT_EAL_Func g_defEalKeyMgmtDsa[];
#endif
#ifdef HITLS_CRYPTO_ED25519
extern const CRYPT_EAL_Func g_defEalKeyMgmtEd25519[];
#endif
#ifdef HITLS_CRYPTO_X25519
extern const CRYPT_EAL_Func g_defEalKeyMgmtX25519[];
#endif
#ifdef HITLS_CRYPTO_RSA
extern const CRYPT_EAL_Func g_defEalKeyMgmtRsa[];
#endif
#ifdef HITLS_CRYPTO_DH
extern const CRYPT_EAL_Func g_defEalKeyMgmtDh[];
#endif
#ifdef HITLS_CRYPTO_ECDSA
extern const CRYPT_EAL_Func g_defEalKeyMgmtEcdsa[];
#endif
#ifdef HITLS_CRYPTO_ECDH
extern const CRYPT_EAL_Func g_defEalKeyMgmtEcdh[];
#endif
#ifdef HITLS_CRYPTO_SM2
extern const CRYPT_EAL_Func g_defEalKeyMgmtSm2[];
#endif
#ifdef HITLS_CRYPTO_PAILLIER
extern const CRYPT_EAL_Func g_defEalKeyMgmtPaillier[];
#endif
#ifdef HITLS_CRYPTO_ELGAMAL
extern const CRYPT_EAL_Func g_defEalKeyMgmtElGamal[];
#endif
#ifdef HITLS_CRYPTO_MLDSA
extern const CRYPT_EAL_Func g_defEalKeyMgmtMlDsa[];
#endif
#ifdef HITLS_CRYPTO_SLH_DSA
extern const CRYPT_EAL_Func g_defEalKeyMgmtSlhDsa[];
#endif
#ifdef HITLS_CRYPTO_MLKEM
extern const CRYPT_EAL_Func g_defEalKeyMgmtMlKem[];
#endif
#ifdef HITLS_CRYPTO_HYBRIDKEM
extern const CRYPT_EAL_Func g_defEalKeyMgmtHybridKem[];
#endif
#ifdef HITLS_CRYPTO_X25519
extern const CRYPT_EAL_Func g_defEalExchX25519[];
#endif
#ifdef HITLS_CRYPTO_DH
extern const CRYPT_EAL_Func g_defEalExchDh[];
#endif
#ifdef HITLS_CRYPTO_ECDH
extern const CRYPT_EAL_Func g_defEalExchEcdh[];
#endif
#ifdef HITLS_CRYPTO_SM2_EXCH
extern const CRYPT_EAL_Func g_defEalExchSm2[];
#else
#define g_defEalExchSm2 NULL
#endif
#if defined(HITLS_CRYPTO_RSA_ENCRYPT) || defined(HITLS_CRYPTO_RSA_DECRYPT)
extern const CRYPT_EAL_Func g_defEalAsymCipherRsa[];
#else
#define g_defEalAsymCipherRsa NULL
#endif
#ifdef HITLS_CRYPTO_SM2_CRYPT
extern const CRYPT_EAL_Func g_defEalAsymCipherSm2[];
#else
#define g_defEalAsymCipherSm2 NULL
#endif
#ifdef HITLS_CRYPTO_PAILLIER
extern const CRYPT_EAL_Func g_defEalAsymCipherPaillier[];
#endif
#ifdef HITLS_CRYPTO_ELGAMAL
extern const CRYPT_EAL_Func g_defEalAsymCipherElGamal[];
#endif
#ifdef HITLS_CRYPTO_DSA
extern const CRYPT_EAL_Func g_defEalSignDsa[];
#endif
#ifdef HITLS_CRYPTO_ED25519
extern const CRYPT_EAL_Func g_defEalSignEd25519[];
#endif
#if defined(HITLS_CRYPTO_RSA_SIGN) || defined(HITLS_CRYPTO_RSA_VERIFY)
extern const CRYPT_EAL_Func g_defEalSignRsa[];
#else
#define g_defEalSignRsa NULL
#endif
#ifdef HITLS_CRYPTO_ECDSA
extern const CRYPT_EAL_Func g_defEalSignEcdsa[];
#endif
#ifdef HITLS_CRYPTO_SM2_SIGN
extern const CRYPT_EAL_Func g_defEalSignSm2[];
#else
#define g_defEalSignSm2 NULL
#endif
#ifdef HITLS_CRYPTO_MLDSA
extern const CRYPT_EAL_Func g_defEalSignMlDsa[];
#endif
#ifdef HITLS_CRYPTO_SLH_DSA
extern const CRYPT_EAL_Func g_defEalSignSlhDsa[];
#endif
#ifdef HITLS_CRYPTO_MLKEM
extern const CRYPT_EAL_Func g_defEalMlKem[];
#endif
#ifdef HITLS_CRYPTO_HYBRIDKEM
extern const CRYPT_EAL_Func g_defEalHybridKeyKem[];
#endif
#endif // HITLS_CRYPTO_PKEY
#ifdef HITLS_CRYPTO_CODECSKEY
#ifdef HITLS_CRYPTO_KEY_EPKI
extern const CRYPT_EAL_Func g_defEalPrvP8Enc2P8[];
#endif
#ifdef HITLS_BSL_PEM
extern const CRYPT_EAL_Func g_defEalPem2Der[];
#endif
#ifdef HITLS_CRYPTO_RSA
extern const CRYPT_EAL_Func g_defEalRsaPrvDer2Key[];
#endif
#ifdef HITLS_CRYPTO_ECDSA
extern const CRYPT_EAL_Func g_defEalEcdsaPrvDer2Key[];
#endif
#ifdef HITLS_CRYPTO_SM2
extern const CRYPT_EAL_Func g_defEalSm2PrvDer2Key[];
#endif
#ifdef HITLS_CRYPTO_RSA
extern const CRYPT_EAL_Func g_defEalP8Der2RsaKey[];
#endif
#ifdef HITLS_CRYPTO_ECDSA
extern const CRYPT_EAL_Func g_defEalP8Der2EcdsaKey[];
#endif
#ifdef HITLS_CRYPTO_SM2
extern const CRYPT_EAL_Func g_defEalP8Der2Sm2Key[];
#endif
#ifdef HITLS_CRYPTO_ED25519
extern const CRYPT_EAL_Func g_defEalP8Der2Ed25519Key[];
#endif
#ifdef HITLS_CRYPTO_RSA
extern const CRYPT_EAL_Func g_defEalSubPubKeyDer2RsaKey[];
#endif
#ifdef HITLS_CRYPTO_ECDSA
extern const CRYPT_EAL_Func g_defEalSubPubKeyDer2EcdsaKey[];
#endif
#ifdef HITLS_CRYPTO_SM2
extern const CRYPT_EAL_Func g_defEalSubPubKeyDer2Sm2Key[];
#endif
#ifdef HITLS_CRYPTO_ED25519
extern const CRYPT_EAL_Func g_defEalSubPubKeyDer2Ed25519Key[];
#endif
#ifdef HITLS_CRYPTO_RSA
extern const CRYPT_EAL_Func g_defEalSubPubKeyWithoutSeqDer2RsaKey[];
#endif
#ifdef HITLS_CRYPTO_ECDSA
extern const CRYPT_EAL_Func g_defEalSubPubKeyWithoutSeqDer2EcdsaKey[];
#endif
#ifdef HITLS_CRYPTO_SM2
extern const CRYPT_EAL_Func g_defEalSubPubKeyWithoutSeqDer2Sm2Key[];
#endif
#ifdef HITLS_CRYPTO_ED25519
extern const CRYPT_EAL_Func g_defEalSubPubKeyWithoutSeqDer2Ed25519Key[];
#endif
#ifdef HITLS_CRYPTO_RSA
extern const CRYPT_EAL_Func g_defEalLowKeyObject2PkeyObject[];
#endif
#ifdef HITLS_CRYPTO_RSA
extern const CRYPT_EAL_Func g_defEalRsaPubDer2Key[];
#endif
#endif // HITLS_CRYPTO_CODECSKEY
#ifdef __cplusplus
}
#endif // __cplusplus
#endif /* HITLS_CRYPTO_PROVIDER */
#endif // CRYPT_EAL_DEFAULT_PROVIDERIMPL_H | 2401_83913325/openHiTLS-examples_2461 | crypto/provider/include/crypt_default_provderimpl.h | C | unknown | 8,594 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CRYPT_PROVIDER_H
#define CRYPT_PROVIDER_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_PROVIDER
#include "crypt_eal_provider.h"
#include "crypt_eal_implprovider.h"
#include "bsl_list.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cpluscplus */
#define CRYPT_EAL_DEFAULT_PROVIDER "default"
// Maximum length of provider name
#define DEFAULT_PROVIDER_NAME_LEN_MAX 255
typedef enum {
CRYPT_PROVIDER_GET_USER_CTX = 1,
CRYPT_PROVIDER_CTRL_MAX,
} CRYPT_ProviderCtrlCmd;
struct EAL_LibCtx {
BslList *providers; // managing providers
BSL_SAL_ThreadLockHandle lock;
char *searchProviderPath;
#ifdef HITLS_CRYPTO_DRBG
void *drbg;
#endif
};
#if defined(HITLS_CRYPTO_ENTROPY) && \
(defined(HITLS_CRYPTO_ENTROPY_GETENTROPY) || defined(HITLS_CRYPTO_ENTROPY_DEVRANDOM) || \
defined(HITLS_CRYPTO_ENTROPY_SYS) || defined(HITLS_CRYPTO_ENTROPY_HARDWARE))
#define HITLS_CRYPTO_ENTROPY_DEFAULT
#endif
int32_t CRYPT_EAL_InitPreDefinedProviders(void);
void CRYPT_EAL_FreePreDefinedProviders(void);
int32_t CRYPT_EAL_DefaultProvInit(CRYPT_EAL_ProvMgrCtx *mgrCtx, BSL_Param *param,
CRYPT_EAL_Func *capFuncs, CRYPT_EAL_Func **outFuncs, void **provCtx);
int32_t CRYPT_EAL_AddNewProvMgrCtx(CRYPT_EAL_LibCtx *libCtx, const char *providerName, const char *providerPath,
CRYPT_EAL_ImplProviderInit init, BSL_Param *param, CRYPT_EAL_ProvMgrCtx **ctx);
int32_t CRYPT_EAL_ProviderGetFuncsAndMgrCtx(CRYPT_EAL_LibCtx *libCtx, int32_t operaId, int32_t algId,
const char *attribute, const CRYPT_EAL_Func **funcs, CRYPT_EAL_ProvMgrCtx **mgrCtx);
CRYPT_EAL_LibCtx* CRYPT_EAL_GetGlobalLibCtx(void);
int32_t CRYPT_EAL_ProviderQuery(CRYPT_EAL_ProvMgrCtx *ctx, int32_t operaId, CRYPT_EAL_AlgInfo **algInfos);
#ifdef __cplusplus
}
#endif /* __cpluscplus */
#endif /* HITLS_CRYPTO_PROVIDER */
#endif /* CRYPT_PROVIDER_H */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/include/crypt_provider.h | C | unknown | 2,443 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include "crypt_cmvp.h"
#include "crypt_errno.h"
#include "bsl_err_internal.h"
#include "crypt_eal_implprovider.h"
#include "crypt_eal_cmvp.h"
#ifdef HITLS_CRYPTO_PROVIDER
static int32_t CRYPT_EAL_SetCmvpSelftestMethod(CRYPT_SelftestCtx *ctx, const CRYPT_EAL_Func *funcs)
{
int32_t index = 0;
EAL_CmvpSelftestMethod *method = BSL_SAL_Calloc(1, sizeof(EAL_CmvpSelftestMethod));
if (method == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
while (funcs[index].id != 0) {
switch (funcs[index].id) {
case CRYPT_EAL_IMPLSELFTEST_NEWCTX:
method->provNewCtx = funcs[index].func;
break;
case CRYPT_EAL_IMPLSELFTEST_GETVERSION:
method->getVersion = funcs[index].func;
break;
case CRYPT_EAL_IMPLSELFTEST_SELFTEST:
method->selftest = funcs[index].func;
break;
case CRYPT_EAL_IMPLSELFTEST_FREECTX:
method->freeCtx = funcs[index].func;
break;
default:
BSL_SAL_FREE(method);
BSL_ERR_PUSH_ERROR(CRYPT_PROVIDER_ERR_UNEXPECTED_IMPL);
return CRYPT_PROVIDER_ERR_UNEXPECTED_IMPL;
}
index++;
}
ctx->method = method;
return CRYPT_SUCCESS;
}
static CRYPT_SelftestCtx *CRYPT_CMVP_SelftestNewCtxInner(CRYPT_EAL_LibCtx *libCtx, const char *attrName)
{
const CRYPT_EAL_Func *funcs = NULL;
void *provCtx = NULL;
int32_t algId = CRYPT_CMVP_PROVIDER_SELFTEST;
int32_t ret = CRYPT_EAL_ProviderGetFuncs(libCtx, CRYPT_EAL_OPERAID_SELFTEST, algId, attrName,
&funcs, &provCtx);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return NULL;
}
CRYPT_SelftestCtx *ctx = BSL_SAL_Calloc(1u, sizeof(CRYPT_SelftestCtx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
ret = CRYPT_EAL_SetCmvpSelftestMethod(ctx, funcs);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
BSL_SAL_FREE(ctx);
return NULL;
}
if (ctx->method->provNewCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_PROVIDER_ERR_IMPL_NULL);
BSL_SAL_FREE(ctx->method);
BSL_SAL_FREE(ctx);
return NULL;
}
ctx->data = ctx->method->provNewCtx(provCtx);
if (ctx->data == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
BSL_SAL_FREE(ctx->method);
BSL_SAL_FREE(ctx);
return NULL;
}
ctx->id = algId;
ctx->isProvider = true;
return ctx;
}
#endif // HITLS_CRYPTO_PROVIDER
CRYPT_SelftestCtx *CRYPT_CMVP_SelftestNewCtx(CRYPT_EAL_LibCtx *libCtx, const char *attrName)
{
#ifdef HITLS_CRYPTO_PROVIDER
return CRYPT_CMVP_SelftestNewCtxInner(libCtx, attrName);
#else
(void)libCtx;
(void)attrName;
return NULL;
#endif
}
const char *CRYPT_CMVP_GetVersion(CRYPT_SelftestCtx *ctx)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return NULL;
}
if (ctx->method == NULL || ctx->method->getVersion == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_NOT_SUPPORT);
return NULL;
}
return ctx->method->getVersion(ctx->data);
}
int32_t CRYPT_CMVP_Selftest(CRYPT_SelftestCtx *ctx, const BSL_Param *param)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ctx->method == NULL || ctx->method->selftest == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_NOT_SUPPORT);
return CRYPT_EAL_ALG_NOT_SUPPORT;
}
return ctx->method->selftest(ctx->data, param);
}
void CRYPT_CMVP_SelftestFreeCtx(CRYPT_SelftestCtx *ctx)
{
if (ctx == NULL) {
return;
}
if (ctx->method != NULL && ctx->method->freeCtx != NULL) {
ctx->method->freeCtx(ctx->data);
}
BSL_SAL_FREE(ctx->method);
BSL_SAL_FREE(ctx);
}
#endif /* HITLS_CRYPTO_CMVP */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp.c | C | unknown | 4,640 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <dlfcn.h>
#include <syslog.h>
#include <stdarg.h>
#include "securec.h"
#include "crypt_cmvp.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_err.h"
#include "crypt_errno.h"
#include "bsl_sal.h"
#include "crypt_cmvp_selftest.h"
#include "cmvp_integrity_hmac.h"
#include "cmvp_common.h"
#define BSL_PARAM_MAX_NUMBER 1000
uint8_t *CMVP_StringsToBins(const char *in, uint32_t *outLen)
{
if (in == NULL) {
return NULL;
}
uint32_t inLen = (uint32_t)strlen(in);
uint8_t *out = NULL;
if (inLen == 0) {
return NULL;
}
// The length of a hexadecimal string must be a multiple of 2.
if (inLen % 2 != 0) {
return NULL;
}
// Length of the hexadecimal string / 2 = Length of the byte stream
inLen = inLen / 2;
out = BSL_SAL_Malloc(inLen);
if (out == NULL) {
return NULL;
}
*outLen = inLen;
// A group of 2 bytes
for (uint32_t i = 0; i < 2 * inLen; i += 2) {
// Formula for converting hex to int: (Hex% 32 + 9)% 25 = int, hexadecimal, 16: high 4 bits.
out[i / 2] = ((uint8_t)in[i] % 32 + 9) % 25 * 16 + ((uint8_t)in[i + 1] % 32 + 9) % 25;
}
return out;
}
void CMVP_WriteSyslog(const char *ident, int32_t priority, const char *format, ...)
{
va_list vargs;
va_start(vargs, format);
openlog(ident, LOG_PID | LOG_ODELAY, LOG_USER);
vsyslog(priority, format, vargs);
closelog();
va_end(vargs);
}
char *CMVP_ReadFile(const char *path, const char *mode, uint32_t *bufLen)
{
int64_t len;
int64_t readLen;
FILE *fp = NULL;
char *buf = NULL;
fp = fopen(path, mode);
if (fp == NULL) {
return false;
}
GOTO_ERR_IF_TRUE(fseek(fp, 0, SEEK_END) != 0, CRYPT_CMVP_COMMON_ERR);
len = ftell(fp);
GOTO_ERR_IF_TRUE(len == -1, CRYPT_CMVP_COMMON_ERR);
buf = BSL_SAL_Malloc((uint32_t)len + 1);
GOTO_ERR_IF_TRUE(buf == NULL, CRYPT_MEM_ALLOC_FAIL);
buf[len] = '\0';
GOTO_ERR_IF_TRUE(fseek(fp, 0, SEEK_SET) != 0, CRYPT_CMVP_COMMON_ERR);
readLen = (int64_t)fread(buf, sizeof(uint8_t), (uint64_t)len, fp);
GOTO_ERR_IF_TRUE(readLen != len && feof(fp) == 0, CRYPT_CMVP_COMMON_ERR);
*bufLen = (uint32_t)readLen;
(void)fclose(fp);
return buf;
ERR:
BSL_SAL_Free(buf);
(void)fclose(fp);
return NULL;
}
static char *CMVP_GetLibPath(void *func)
{
Dl_info info;
char *path = NULL;
GOTO_ERR_IF_TRUE(dladdr(func, &info) == 0, CRYPT_CMVP_COMMON_ERR);
path = BSL_SAL_Malloc((uint32_t)strlen(info.dli_fname) + 1);
GOTO_ERR_IF_TRUE(path == NULL, CRYPT_MEM_ALLOC_FAIL);
(void)memcpy_s(path, strlen(info.dli_fname), info.dli_fname, strlen(info.dli_fname));
path[strlen(info.dli_fname)] = '\0';
return path;
ERR:
BSL_SAL_Free(path);
return NULL;
}
int32_t CMVP_CheckIntegrity(void *libCtx, const char *attrName, CRYPT_MAC_AlgId macId)
{
int32_t ret = CRYPT_CMVP_ERR_INTEGRITY;
char *libCryptoPath = NULL;
char *libBslPath = NULL;
if (CRYPT_CMVP_SelftestProviderMac(libCtx, attrName, macId) != true) {
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
libCryptoPath = CMVP_GetLibPath(CMVP_IntegrityHmac);
GOTO_ERR_IF_TRUE(libCryptoPath == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(CMVP_IntegrityHmac(libCtx, attrName, libCryptoPath, macId) == false, CRYPT_CMVP_ERR_INTEGRITY);
libBslPath = CMVP_GetLibPath(BSL_SAL_Malloc);
GOTO_ERR_IF_TRUE(libBslPath == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(CMVP_IntegrityHmac(libCtx, attrName, libBslPath, macId) == false, CRYPT_CMVP_ERR_INTEGRITY);
ret = CRYPT_SUCCESS;
ERR:
BSL_SAL_Free(libCryptoPath);
BSL_SAL_Free(libBslPath);
return ret;
}
static int32_t CopyParam(BSL_Param *param, int32_t *selfTestFlag, BSL_Param **newParam)
{
int32_t index = 0;
if (param != NULL) {
while (param[index].key != 0 && index < BSL_PARAM_MAX_NUMBER) {
index++;
}
if (index >= BSL_PARAM_MAX_NUMBER) {
BSL_ERR_PUSH_ERROR(CRYPT_CMVP_COMMON_ERR);
return CRYPT_CMVP_COMMON_ERR;
}
}
int32_t count = index + 2;
BSL_Param *tmpParam = (BSL_Param *)BSL_SAL_Calloc(count, sizeof(BSL_Param));
if (tmpParam == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return CRYPT_MEM_ALLOC_FAIL;
}
if (param != NULL) {
(void)memcpy_s(tmpParam, count * sizeof(BSL_Param), param, index * sizeof(BSL_Param));
}
int32_t ret = BSL_PARAM_InitValue(&tmpParam[index], CRYPT_PARAM_CMVP_INTERNAL_LIBCTX_FLAG, BSL_PARAM_TYPE_INT32,
selfTestFlag, sizeof(int32_t));
if (ret != BSL_SUCCESS) {
BSL_SAL_FREE(tmpParam);
return ret;
}
*newParam = tmpParam;
return CRYPT_SUCCESS;
}
int32_t CMVP_CreateInternalLibCtx(BSL_Param *param, CRYPT_EAL_LibCtx **libCtx, void *func)
{
int32_t selfTestFlag = 1;
int32_t ret = CRYPT_SUCCESS;
char *libPath = NULL;
BSL_Param *newParam = NULL;
CRYPT_EAL_LibCtx *ctx = NULL;
do {
ret = CopyParam(param, &selfTestFlag, &newParam);
if (ret != CRYPT_SUCCESS) {
break;
}
ctx = CRYPT_EAL_LibCtxNew();
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
ret = CRYPT_MEM_ALLOC_FAIL;
break;
}
libPath = CMVP_GetLibPath(func);
if (libPath == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_CMVP_COMMON_ERR);
ret = CRYPT_CMVP_COMMON_ERR;
break;
}
ret = CRYPT_EAL_ProviderLoad(ctx, 0, libPath, newParam, NULL);
if (ret != CRYPT_SUCCESS) {
break;
}
*libCtx = ctx;
} while (0);
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_LibCtxFree(ctx);
}
BSL_SAL_Free(libPath);
BSL_SAL_Free(newParam);
return ret;
}
bool CMVP_CheckIsInternalLibCtx(BSL_Param *param)
{
if (param == NULL) {
return false;
}
BSL_Param *temp = BSL_PARAM_FindParam(param, CRYPT_PARAM_CMVP_INTERNAL_LIBCTX_FLAG);
if (temp != NULL && temp->valueType == BSL_PARAM_TYPE_INT32) {
return true;
}
return false;
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */ | 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_common.c | C | unknown | 7,001 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CMVP_COMMON_H
#define CMVP_COMMON_H
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <stdint.h>
#include <stdbool.h>
#include <syslog.h>
#include "crypt_cmvp.h"
#include "crypt_types.h"
#include "crypt_algid.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
uint8_t *CMVP_StringsToBins(const char *in, uint32_t *outLen); // Converting a hexadecimal string to a buf array
void CMVP_WriteSyslog(const char *ident, int32_t priority, const char *format, ...)
__attribute__((format(printf, 3, 4))); // Write syslog
char *CMVP_ReadFile(const char *path, const char *mode, uint32_t *bufLen); // Read file
int32_t CMVP_CheckIntegrity(void *libCtx, const char *attrName, CRYPT_MAC_AlgId macId);
int32_t CMVP_CreateInternalLibCtx(BSL_Param *param, CRYPT_EAL_LibCtx **libCtx, void *func);
bool CMVP_CheckIsInternalLibCtx(BSL_Param *param);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
#endif // CMVP_COMMON_H
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_common.h | C | unknown | 1,652 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "cmvp_common.h"
#include "crypt_eal_mac.h"
#include "crypt_errno.h"
#include "bsl_err.h"
#include "securec.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
#include "cmvp_integrity_hmac.h"
#ifndef CMVP_INTEGRITYKEY
#define CMVP_INTEGRITYKEY ""
#endif
const char *GetIntegrityKey(void)
{
return CMVP_INTEGRITYKEY;
}
static uint8_t *GetLibHmac(void *libCtx, const char *attrName, CRYPT_MAC_AlgId id, const char *libPath,
uint32_t *hmacLen)
{
char *buf = NULL;
uint8_t *hmac = NULL;
uint32_t bufLen;
CRYPT_EAL_MacCtx *ctx = NULL;
buf = CMVP_ReadFile(libPath, "rb", &bufLen);
GOTO_ERR_IF_TRUE(buf == NULL, CRYPT_CMVP_COMMON_ERR);
ctx = CRYPT_EAL_ProviderMacNewCtx(libCtx, id, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
*hmacLen = CRYPT_EAL_GetMacLen(ctx);
hmac = BSL_SAL_Malloc(*hmacLen);
GOTO_ERR_IF_TRUE(hmac == NULL, CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacInit(ctx, (const uint8_t *)GetIntegrityKey(), (uint32_t)strlen(GetIntegrityKey())) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_INTEGRITY);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacUpdate(ctx, (uint8_t *)buf, bufLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_INTEGRITY);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacFinal(ctx, hmac, hmacLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_INTEGRITY);
BSL_SAL_Free(buf);
CRYPT_EAL_MacFreeCtx(ctx);
return hmac;
ERR:
BSL_SAL_Free(buf);
BSL_SAL_Free(hmac);
CRYPT_EAL_MacFreeCtx(ctx);
return NULL;
}
static uint8_t *GetExpectHmac(const char *hmacPath, uint32_t *hmacLen)
{
uint8_t *hmac = NULL;
char *buf = NULL;
uint32_t bufLen;
char seps[] = " \n";
char *tmp = NULL;
char *nextTmp = NULL;
buf = CMVP_ReadFile(hmacPath, "r", &bufLen);
GOTO_ERR_IF_TRUE(buf == NULL, CRYPT_CMVP_COMMON_ERR);
// HMAC-SHA256(libhitls_crypto.so)= 76a90d73cb68585837a2ebdf009e9e485acba4fd718bae898bdc354537f8a72a\n
// The format of the generated .hmac file is as shown in the preceding figure.
// The content between spaces and newline characters is truncated.
tmp = strtok_s(buf, seps, &nextTmp);
GOTO_ERR_IF_TRUE(tmp == NULL, CRYPT_CMVP_COMMON_ERR);
tmp = strtok_s(NULL, seps, &nextTmp);
GOTO_ERR_IF_TRUE(tmp == NULL, CRYPT_CMVP_COMMON_ERR);
hmac = CMVP_StringsToBins(tmp, hmacLen);
GOTO_ERR_IF_TRUE(hmac == NULL, CRYPT_CMVP_COMMON_ERR);
BSL_SAL_Free(buf);
return hmac;
ERR:
BSL_SAL_Free(buf);
BSL_SAL_Free(hmac);
return NULL;
}
bool CMVP_IntegrityHmac(void *libCtx, const char *attrName, const char *libPath, CRYPT_MAC_AlgId id)
{
bool ret = false;
char *hmacPath = NULL;
uint8_t *hmac = NULL;
uint8_t *expectHmac = NULL;
uint32_t hmacLen, expectHmacLen;
hmacPath = BSL_SAL_Malloc((uint32_t)strlen(libPath) + (uint32_t)strlen(".hmac") + 1);
GOTO_ERR_IF_TRUE(hmacPath == NULL, CRYPT_MEM_ALLOC_FAIL);
(void)sprintf_s(hmacPath, strlen(libPath) + strlen(".hmac") + 1, "%s%s", libPath, ".hmac");
hmacPath[strlen(libPath) + strlen(".hmac")] = '\0';
hmac = GetLibHmac(libCtx, attrName, id, libPath, &hmacLen);
GOTO_ERR_IF_TRUE(hmac == NULL, CRYPT_CMVP_ERR_INTEGRITY);
expectHmac = GetExpectHmac(hmacPath, &expectHmacLen);
GOTO_ERR_IF_TRUE(expectHmac == NULL, CRYPT_CMVP_ERR_INTEGRITY);
GOTO_ERR_IF_TRUE(hmacLen != expectHmacLen, CRYPT_CMVP_ERR_INTEGRITY);
GOTO_ERR_IF_TRUE(memcmp(expectHmac, hmac, hmacLen) != 0, CRYPT_CMVP_ERR_INTEGRITY);
ret = true;
ERR:
BSL_SAL_Free(hmac);
BSL_SAL_Free(expectHmac);
BSL_SAL_Free(hmacPath);
return ret;
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_integrity_hmac.c | C | unknown | 4,406 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CMVP_INTEGRITY_HMAC_H
#define CMVP_INTEGRITY_HMAC_H
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <stdbool.h>
#include "crypt_algid.h"
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
// When the HMAC is used to perform integrity verification, a failure message is returned,
// and the module does not enter the error state.
bool CMVP_IntegrityHmac(void *libCtx, const char *attrName, const char *libPath, CRYPT_MAC_AlgId id);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
#endif /* CMVP_INTEGRITY_HMAC_H */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_integrity_hmac.h | C | unknown | 1,253 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <math.h>
#include <float.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_log_internal.h"
#include "bsl_binlog_id.h"
#include "crypt_errno.h"
#include "crypt_cmvp.h"
#define ALPHA (0.01)
#define MAXITERTIMES 1e5
#define BITSPERBYTE 8
static uint8_t *Byte2Bits(const uint8_t *data, uint32_t len)
{
if (data == NULL || len == 0) {
return NULL;
}
uint8_t *bits = BSL_SAL_Malloc(sizeof(uint8_t) * (len * BITSPERBYTE));
if (bits == NULL) {
return NULL;
}
for (uint32_t i = 0; i < len; i++) {
uint32_t j = i * 8;
bits[j + 7] = data[i] & 0x01; // bit0 offset 7
bits[j + 6] = (data[i] >> 1) & 0x01; // bit1 offset 6
bits[j + 5] = (data[i] >> 2) & 0x01; // bit2 offset 5
bits[j + 4] = (data[i] >> 3) & 0x01; // bit3 offset 4
bits[j + 3] = (data[i] >> 4) & 0x01; // bit4 offset 3
bits[j + 2] = (data[i] >> 5) & 0x01; // bit5 offset 2
bits[j + 1] = (data[i] >> 6) & 0x01; // bit6 offset 1
bits[j] = (data[i] >> 7) & 0x01; // bit7 offset 0
}
return bits;
}
static double IgammaFraction(double a, double x);
static double IgammaSeries(double a, double x);
// Upper Incomplete Gamma Function
static double Igamc(double a, double x)
{
if (a <= 0 || x <= 0) {
return 1.0;
}
if (x < a + 1.0) {
return 1.0 - IgammaSeries(a, x);
} else {
return IgammaFraction(a, x);
}
}
// Evaluate upper igamma by continued fraction
// use Lentz's algorithm to calculate the continued fraction
// where ak = k(a - k), bk = (x - a + 2k + 1)
// define
// C_n = b_n + a_n / C_(n-1)
// D_n = 1 / (b_n + a_n * D_(n - 1))
// then f_n = C_n * D_n * f_n-1 converges to Igamc
// see https://en.wikipedia.org/wiki/Lentz%27s_algorithm for detailed information.
static double IgammaFraction(double a, double x)
{
double an, bn = x + 1.0 - a;
double factor = a * log(x) - x - lgamma(a);
if (factor >= DBL_MAX_EXP) {
return 1.0; // float underflow
}
factor = exp(factor);
double c = 1 / DBL_MIN;
double d = 1.0 / bn;
double prod = d;
for (uint32_t k = 1; k < MAXITERTIMES; k++) {
an = ((double)k) * (a - (double)k); // ak = k(a - k)
bn += 2.0; // bk = (x - a + 2.0 * k + 1)
c = bn + an / c;
d = bn + an * d;
if (fabs(c) < DBL_MIN) {
break; // float underflow
}
if (fabs(d) < DBL_MIN) {
break; // float underflow
}
d = 1 / d;
prod *= (d * c);
}
return factor * prod;
}
// Evaluate lower incomplete gamma function by series representation
static double IgammaSeries(double a, double x)
{
double sum = 0, bn = 1, factor, ak = a;
factor = a * log(x) - x - lgamma(a);
if (factor >= DBL_MAX_EXP) {
return 0.0; // float underflow
}
factor = exp(factor);
for (uint32_t k = 1; k < MAXITERTIMES; k++) {
sum += bn;
ak += 1;
bn *= x / ak;
}
return (sum / a) * factor;
}
static int32_t MonobitTest(const uint8_t *data, uint32_t len)
{
double s = 0.0;
double v;
double pValue;
for (uint32_t i = 0; i < len; i++) {
s += 2 * (data[i]) - 1; // 2: convert 0, 1 to -1, 1
}
v = fabs(s) / sqrt(len);
pValue = erfc((v / sqrt(2.0))); // 2.0: divide by square root of 2.
return pValue >= ALPHA ? CRYPT_SUCCESS : CRYPT_CMVP_RANDOMNESS_ERR;
}
static int32_t CMVP_MonobitTest(const uint8_t *data, uint32_t len)
{
if (data == NULL) {
return CRYPT_CMVP_RANDOMNESS_ERR;
}
// length of data must be larger than 100 bits in GM/T 0005-2016
return len > 100 ? MonobitTest(data, len) : CRYPT_CMVP_RANDOMNESS_ERR;
}
static uint8_t DataToIndex(const uint8_t* data, const int32_t blocklen)
{
uint8_t s = 0;
for (int32_t i = 0; i < blocklen; i++) {
s += (data[i] << (blocklen - i - 1));
}
return s;
}
static int32_t PokerTest(const uint8_t *data, uint32_t len, int32_t blocklen)
{
uint32_t N = len / blocklen;
uint32_t maxComb = (uint32_t)pow(2.0, (double)blocklen);
uint32_t *dict = BSL_SAL_Malloc(maxComb * sizeof(uint32_t));
if (dict == NULL) {
return CRYPT_CMVP_RANDOMNESS_ERR;
}
memset_s(dict, maxComb * sizeof(uint32_t), 0, maxComb * sizeof(uint32_t));
for (uint32_t i = 0; (uint32_t)(i + blocklen) <= len; i += (uint32_t)blocklen) {
dict[DataToIndex(data + i, blocklen)]++;
}
double s = 0.0;
for (uint32_t i = 0; i < maxComb; i++) {
s += pow(dict[i], 2); // 2: square each dict value
}
double v = (pow(2.0, (double)blocklen) / (double) N) * s - N;
double pValue = Igamc(((double)maxComb - 1.0) / 2.0, v / 2.0); // p_value = igamc((2^m - 1) / 2, v / 2)
BSL_SAL_FREE(dict);
return pValue >= ALPHA ? CRYPT_SUCCESS : CRYPT_CMVP_RANDOMNESS_ERR;
}
static int32_t CMVP_PokerTest(const uint8_t *data, uint32_t len)
{
if (data == NULL || len == 0) {
return CRYPT_CMVP_RANDOMNESS_ERR;
}
// blocklen can be 2, 4 or 8 in GM/T 0005-2016, blocklen can't be greater than 8.
for (int blocklen = 8; blocklen >= 2; blocklen -= 2) {
// [n/m] >= 5 * 2^m in GM/T 0005-2016 chart B.1
if ((uint32_t)(len / blocklen) >= 5 * pow(2, blocklen)) {
return PokerTest(data, len, blocklen);
}
}
return CRYPT_CMVP_RANDOMNESS_ERR;
}
typedef struct {
int32_t (*testFunc)(const uint8_t *data, uint32_t len);
char *name;
} DRBG_TEST;
int32_t CRYPT_CMVP_RandomnessTest(const uint8_t *data, const uint32_t len)
{
int32_t ret = CRYPT_SUCCESS;
if (len > UINT32_MAX / BITSPERBYTE) {
return CRYPT_CMVP_RANDOMNESS_ERR;
}
uint8_t *bits = Byte2Bits(data, len);
if (bits == NULL) {
return CRYPT_CMVP_RANDOMNESS_ERR;
}
const DRBG_TEST testList[] = {
{CMVP_MonobitTest, "BIT FREQUENCY TEST"},
{CMVP_PokerTest, "POKER TEST"},
};
for (uint32_t i = 0; i < sizeof(testList) / sizeof(testList[0]); i++) {
if (testList[i].testFunc != NULL && testList[i].testFunc(bits, len * BITSPERBYTE) != CRYPT_SUCCESS) {
ret = CRYPT_CMVP_RANDOMNESS_ERR;
break;
}
}
BSL_SAL_FREE(bits);
return ret;
}
#endif /* HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_randomness.c | C | unknown | 6,960 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_cipher.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
const char *key;
const char *iv;
const char *aad;
const char *plaintext;
const char *ciphertext;
const char *tag;
} CMVP_CHACHA20POLY1305_VECTOR;
// https://datatracker.ietf.org/doc/html/rfc7539.html#page-22
static const CMVP_CHACHA20POLY1305_VECTOR CHACHA20POLY1305_VECTOR = {
.key = "808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f",
.iv = "070000004041424344454647",
.aad = "50515253c0c1c2c3c4c5c6c7",
.plaintext = "4c616469657320616e642047656e746c656d656e206f662074686520636c617373206f6620273939"
"3a204966204920636f756c64206f6666657220796f75206f6e6c79206f6e652074697020666f7220"
"746865206675747572652c2073756e73637265656e20776f756c642062652069742e",
.ciphertext = "d31a8d34648e60db7b86afbc53ef7ec2a4aded51296e08fea9e2b5a736ee62d63dbea45e8ca96712"
"82fafb69da92728b1a71de0a9e060b2905d6a5b67ecd3b3692ddbd7f2d778b8c9803aee328091b58"
"fab324e4fad675945585808b4831d7bc3ff4def08e4b7a9de576d26586cec64b6116",
.tag = "1ae10b594f09e26a7e902ecbd0600691"
};
static bool GetData(CRYPT_Data *key, CRYPT_Data *iv, CRYPT_Data *aad, CRYPT_Data *data, CRYPT_Data *cipher)
{
key->data = CMVP_StringsToBins(CHACHA20POLY1305_VECTOR.key, &(key->len));
GOTO_ERR_IF_TRUE(key->data == NULL, CRYPT_CMVP_COMMON_ERR);
iv->data = CMVP_StringsToBins(CHACHA20POLY1305_VECTOR.iv, &(iv->len));
GOTO_ERR_IF_TRUE(iv->data == NULL, CRYPT_CMVP_COMMON_ERR);
aad->data = CMVP_StringsToBins(CHACHA20POLY1305_VECTOR.aad, &(aad->len));
GOTO_ERR_IF_TRUE(aad->data == NULL, CRYPT_CMVP_COMMON_ERR);
data->data = CMVP_StringsToBins(CHACHA20POLY1305_VECTOR.plaintext, &(data->len));
GOTO_ERR_IF_TRUE(data->data == NULL, CRYPT_CMVP_COMMON_ERR);
cipher->data = CMVP_StringsToBins(CHACHA20POLY1305_VECTOR.ciphertext, &(cipher->len));
GOTO_ERR_IF_TRUE(cipher->data == NULL, CRYPT_CMVP_COMMON_ERR);
return true;
ERR:
return false;
}
static void FreeData(CRYPT_Data key, CRYPT_Data iv, CRYPT_Data aad, CRYPT_Data data, CRYPT_Data cipher)
{
BSL_SAL_Free(key.data);
BSL_SAL_Free(iv.data);
BSL_SAL_Free(aad.data);
BSL_SAL_Free(data.data);
BSL_SAL_Free(cipher.data);
}
static bool CRYPT_CMVP_SelftestChacha20poly1305Internal(void *libCtx, const char *attrName)
{
bool ret = false;
CRYPT_Data key = { NULL, 0 };
CRYPT_Data iv = { NULL, 0 };
CRYPT_Data aad = { NULL, 0 };
CRYPT_Data data = { NULL, 0 };
CRYPT_Data cipher = { NULL, 0 };
CRYPT_Data tag = { NULL, 0 };
uint8_t *out = NULL;
uint8_t *outTag = NULL;
uint32_t outLen;
uint32_t first;
int32_t err = CRYPT_CMVP_ERR_ALGO_SELFTEST;
CRYPT_EAL_CipherCtx *ctx = NULL;
GOTO_ERR_IF_TRUE(!GetData(&key, &iv, &aad, &data, &cipher), err);
tag.data = CMVP_StringsToBins(CHACHA20POLY1305_VECTOR.tag, &(tag.len));
GOTO_ERR_IF_TRUE(tag.data == NULL, CRYPT_CMVP_COMMON_ERR);
outTag = BSL_SAL_Malloc(tag.len);
outLen = cipher.len;
out = BSL_SAL_Malloc(outLen);
GOTO_ERR_IF_TRUE(outTag == NULL || out == NULL, CRYPT_MEM_ALLOC_FAIL);
first = data.len / 2; // The length of the data in the first operation is 1/2 of the data.
ctx = CRYPT_EAL_ProviderCipherNewCtx(libCtx, CRYPT_CIPHER_CHACHA20_POLY1305, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherInit(ctx, key.data, key.len, iv.data, iv.len, true) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad.data, aad.len) != CRYPT_SUCCESS, err);
outLen = first;
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherUpdate(ctx, data.data, first, out, &outLen) != CRYPT_SUCCESS, err);
outLen = data.len - first;
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherUpdate(ctx, data.data + first, data.len - first,
out + first, &outLen) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, outTag, (uint32_t)tag.len) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(memcmp(out, cipher.data, cipher.len) != 0, err);
GOTO_ERR_IF_TRUE(memcmp(outTag, tag.data, tag.len) != 0, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherInit(ctx, key.data, key.len, iv.data, iv.len, false) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, aad.data, aad.len) != CRYPT_SUCCESS, err);
outLen = cipher.len;
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherUpdate(ctx, cipher.data, cipher.len, out, &outLen) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(memcmp(out, data.data, data.len) != 0, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, outTag, (uint32_t)tag.len) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(memcmp(outTag, tag.data, tag.len) != 0, err);
ret = true;
ERR:
FreeData(key, iv, aad, data, cipher);
BSL_SAL_Free(tag.data);
BSL_SAL_Free(outTag);
BSL_SAL_Free(out);
CRYPT_EAL_CipherFreeCtx(ctx);
return ret;
}
bool CRYPT_CMVP_SelftestChacha20poly1305(void)
{
return CRYPT_CMVP_SelftestChacha20poly1305Internal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderChacha20poly1305(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestChacha20poly1305Internal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */ | 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_chacha20poly1305.c | C | unknown | 6,126 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <stdio.h>
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_cipher.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_local_types.h"
#include "bsl_sal.h"
#include <securec.h>
typedef struct {
uint32_t id;
const char *key;
const char *aad;
const char *iv;
const char *plaintext;
const char *ciphertext;
const char *tag;
uint32_t mode;
} CMVP_CIPHER_VECTOR;
// https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38a.pdf
static const CMVP_CIPHER_VECTOR CIPHER_VECTOR[] = {
// CRYPT_CIPHER_AES128_CBC
{
.id = CRYPT_CIPHER_AES128_CBC,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "7649abac8119b246cee98e9b12e9197d",
.tag = NULL,
.mode = CRYPT_MODE_CBC
},
// CRYPT_CIPHER_AES192_CBC
{
.id = CRYPT_CIPHER_AES192_CBC,
.key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "4f021db243bc633d7178183a9fa071e8",
.tag = NULL,
.mode = CRYPT_MODE_CBC
},
// CRYPT_CIPHER_AES256_CBC
{
.id = CRYPT_CIPHER_AES256_CBC,
.key = "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "f58c4c04d6e5f1ba779eabfb5f7bfbd6",
.tag = NULL,
.mode = CRYPT_MODE_CBC
},
// CRYPT_CIPHER_AES128_CTR
{
.id = CRYPT_CIPHER_AES128_CTR,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "874d6191b620e3261bef6864990db6ce",
.tag = NULL,
.mode = CRYPT_MODE_CTR
},
// CRYPT_CIPHER_AES192_CTR
{
.id = CRYPT_CIPHER_AES192_CTR,
.key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b",
.aad = NULL,
.iv = "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "1abc932417521ca24f2b0459fe7e6e0b",
.tag = NULL,
.mode = CRYPT_MODE_CTR
},
// CRYPT_CIPHER_AES256_CTR
{
.id = CRYPT_CIPHER_AES256_CTR,
.key = "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
.aad = NULL,
.iv = "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "601ec313775789a5b7a7f504bbf3d228",
.tag = NULL,
.mode = CRYPT_MODE_CTR
},
// CRYPT_CIPHER_AES128_ECB
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/
// aes/XTSTestVectors.zip
{
.id = CRYPT_CIPHER_AES128_ECB,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = NULL,
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "3ad77bb40d7a3660a89ecaf32466ef97",
.tag = NULL,
.mode = CRYPT_MODE_ECB
},
// CRYPT_CIPHER_AES192_ECB
{
.id = CRYPT_CIPHER_AES192_ECB,
.key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b",
.aad = NULL,
.iv = NULL,
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "bd334f1d6e45f25ff712a214571fa5cc",
.tag = NULL,
.mode = CRYPT_MODE_ECB
},
// CRYPT_CIPHER_AES256_ECB
{
.id = CRYPT_CIPHER_AES256_ECB,
.key = "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
.aad = NULL,
.iv = NULL,
.plaintext = "6bc1bee22e409f96e93d7e117393172a",
.ciphertext = "f3eed1bdb5d2a03c064b5a7e3db181f8",
.tag = NULL,
.mode = CRYPT_MODE_ECB
},
// CRYPT_CIPHER_AES128_XTS
{
.id = CRYPT_CIPHER_AES128_XTS,
.key = "a1b90cba3f06ac353b2c343876081762090923026e91771815f29dab01932f2f",
.aad = NULL,
.iv = "4faef7117cda59c66e4b92013e768ad5",
.plaintext = "ebabce95b14d3c8d6fb350390790311c",
.ciphertext = "778ae8b43cb98d5a825081d5be471c63",
.tag = NULL,
.mode = CRYPT_MODE_XTS
},
// CRYPT_CIPHER_AES256_XTS
{
.id = CRYPT_CIPHER_AES256_XTS,
.key = "e149be00177d76b7c1d85bcbb6b5054ee10b9f51cd73f59e0840628b9e7d854e2e1c0a"
"b0537186a2a7c314bbc5eb23b6876a26bcdbf9e6b758d1cae053c2f278",
.aad = NULL,
.iv = "0ea18818fab95289b1caab4e61349501",
.plaintext = "f5f101d8e3a7681b1ddb21bd2826b24e32990bca49b39291b5369a9bca277d75",
.ciphertext = "5bf2479393cc673306fbb15e72600598e33d4d8a470727ce098730fd80afa959",
.tag = NULL,
.mode = CRYPT_MODE_XTS
},
// CRYPT_CIPHER_AES128_CCM
// http://csrc.nist.gov/groups/STM/cavp/documents/mac/ccmtestvectors.zip
{
.id = CRYPT_CIPHER_AES128_CCM,
.key = "f149e41d848f59276cfddd743bafa9a9",
.aad = "f5827e",
.iv = "14b756d66fc51134e203d1c6f9",
.plaintext = "9759e6f21f5a588010f57e6d6eae178d8b20ab59cda66f42",
.ciphertext = "f634bf00f1f9f1f93f41049d7f3797b05e805f0b14850f4e78e2a23411147a6187da6818506232ee",
.tag = NULL,
.mode = CRYPT_MODE_CCM
},
// CRYPT_CIPHER_AES192_CCM
{
.id = CRYPT_CIPHER_AES192_CCM,
.key = "393dcac5a28d77297946d7ab471ae03bd303ba3499e2ce26",
.aad = "1c8b",
.iv = "fe7329f343f6e726a90b11ae37",
.plaintext = "262f4ac988812500cb437f52f0c182148e85a0bec67a2736",
.ciphertext = "e6d43f822ad168aa9c2e29c07f4592d7bbeb0203f418f3020ecdbc200be353112faf20e2be711908",
.tag = NULL,
.mode = CRYPT_MODE_CCM
},
// CRYPT_CIPHER_AES256_CCM
{
.id = CRYPT_CIPHER_AES256_CCM,
.key = "c5a850167a5bfdf56636ce9e56e2952855504e35cc4f5d24ee5e168853be82d8",
.aad = "4759557e9bab",
.iv = "c45b165477e8bfa9ca3a1cd3ca",
.plaintext = "e758796d7db73bccb1697c42df691ac57974b40ca9186a43",
.ciphertext = "93ad58bd5f4f77ac4f92b0ae16c62489e4074c7f152e2ed8a88179e0d32f4928eff13b4ce2873338",
.tag = NULL,
.mode = CRYPT_MODE_CCM
},
// CRYPT_CIPHER_AES128_GCM
// http://csrc.nist.gov/groups/STM/cavp/documents/mac/gcmtestvectors.zip
{
.id = CRYPT_CIPHER_AES128_GCM,
.key = "07a6be880a58f572dbc2ad74a56db8b6",
.aad = "de4269feea1a439d6e8990fd6f9f9d5bc67935294425255ea89b6f6772d680fd656b06"
"581a5d8bc5c017ab532b4a9b83a55fde58cdfb3d2a8fef3aa426bc59d3e32f09d3cc20"
"b1ceb9a9e349d1068a0aa3d39617fae0582ccef0",
.iv = "95fc6654e6dc3a8adf5e7a69",
.plaintext = "7680b48b5d28f38cdeab2d5851769394a3e141b990ec4bdf79a33e5315ac0338",
.ciphertext = "095635c7e0eac0fc1059e67e1a936b6f72671121f96699fed520e5f8aff777f0",
.tag = "b2235f6d4bdd7b9c0901711048859d47",
.mode = CRYPT_MODE_GCM
},
// CRYPT_CIPHER_AES192_GCM
{
.id = CRYPT_CIPHER_AES192_GCM,
.key = "4e2d3d59e95884dc3aab32afdb96938cc6e9016d7f21e95f",
.aad = "bd0dbced527c4df9e76c67405cfd0536ef45d6a392b789370356d71a12ee0cacbca6d8a8caa96d4c89923ddb6ba96622",
.iv = "48fd791bf49a798a54fcdc60",
.plaintext = "8e36651ba5bf9a6f903e01080083feeb",
.ciphertext = "f96e2cc58714fd512b1fdbeba770b460",
.tag = "63dfe1bbd756237a43150c82341486",
.mode = CRYPT_MODE_GCM
},
// CRYPT_CIPHER_AES256_GCM
{
.id = CRYPT_CIPHER_AES256_GCM,
.key = "4c8cacccd8a55ec4222f3ec3996b23c4e86f9ab9c1312d53a7eb9b8891085ad9",
.aad = "7dc38ba88808f3e0c7c08111e3f305b7f26ebb0f8915ab1d06b6eaa09ec9258fef04f4"
"0c174d7cf4161653582058e611d667077""cbf0a974b632ed8d486dd807e2d9e8d8ef3"
"749d2b2105e2a3161fe0b42b09fae30db42958aa94",
.iv = "d9e80f9ab45c186c846b3605",
.plaintext = "24ed8a0023a9e11d127488234c285956",
.ciphertext = "4df94bd82b1b284e2dda6dccbbe5076f",
.tag = "241e6c864aabc4a99e344a5d",
.mode = CRYPT_MODE_GCM
},
// CRYPT_CIPHER_CHACHA20_POLY1305
{
.id = CRYPT_CIPHER_CHACHA20_POLY1305,
.key = NULL,
.aad = NULL,
.iv = NULL,
.plaintext = NULL,
.ciphertext = NULL,
.tag = NULL,
.mode = CRYPT_MODE_CHACHA20_POLY1305
},
// CRYPT_CIPHER_SM4_CBC
// http://c.gb688.cn/bzgk/gb/showGb?type=online&hcno=4F89D833626340B1F71068D25EAC737D
// GB/T 17964-2021
{
.id = CRYPT_CIPHER_SM4_CBC,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = "000102030405060708090A0b0C0D0E0F",
.plaintext = "6BC1BEE22E409F96E93D7E117393172A",
.ciphertext = "AC529AF989A62FCE9CDDC5FFB84125CA",
.tag = NULL,
.mode = CRYPT_MODE_CBC
},
// CRYPT_CIPHER_SM4_XTS
// GB/T 17964-2021
{
.id = CRYPT_CIPHER_SM4_XTS,
.key = "2b7e151628aed2a6abf7158809cf4f3c000102030405060708090a0b0c0d0e0f",
.aad = NULL,
.iv = "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
.plaintext = "6BC1BEE22E409F96E93D7E117393172AAE2D8A571E03AC9C9EB76FAC45AF8E5130C81C46A35CE411E5FBC1191A0A52EFF69F2445DF4F9B17",
.ciphertext = "E9538251C71D7B80BBE4483FEF497BD12C5C581BD6242FC51E08964FB4F60FDB0BA42F63499279213D318D2C11F6886E903BE7F93A1B3479",
.tag = NULL,
.mode = CRYPT_MODE_XTS
},
// CRYPT_CIPHER_SM4_ECB
// GB/T 17964-2021
{
.id = CRYPT_CIPHER_SM4_ECB,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = NULL,
.plaintext = "6BC1BEE22E409F96E93D7E117393172A",
.ciphertext = "A51411ff04a711443891fce7ab842a29",
.tag = NULL,
.mode = CRYPT_MODE_ECB
},
// CRYPT_CIPHER_SM4_CTR
// GB/T 17964-2021
{
.id = CRYPT_CIPHER_SM4_CTR,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
.plaintext = "6BC1BEE22E409F96E93D7E117393172A",
.ciphertext = "14AE4A72B97A93CE1216CCD998E371C1",
.tag = NULL,
.mode = CRYPT_MODE_CTR
},
// CRYPT_CIPHER_SM4_GCM
// https://www.rfc-editor.org/rfc/rfc8998.html
{
.id = CRYPT_CIPHER_SM4_GCM,
.key = "0123456789ABCDEFFEDCBA9876543210",
.aad = "FEEDFACEDEADBEEFFEEDFACEDEADBEEFABADDAD2",
.iv = "00001234567800000000ABCD",
.plaintext = "AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFEEEEEEEEEEEEEEEEAAAAAAAAAAAAAAAA",
.ciphertext = "17F399F08C67D5EE19D0DC9969C4BB7D5FD46FD3756489069157B282BB200735D82710CA5C22F0CCFA7CBF93D496AC15A56834CBCF98C397B4024A2691233B8D",
.tag = "83DE3541E4C2B58177E065A9BF7B62EC",
.mode = CRYPT_MODE_GCM
},
// CRYPT_CIPHER_SM4_CFB
// GB/T 17964-2021
{
.id = CRYPT_CIPHER_SM4_CFB,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = "000102030405060708090A0B0C0D0E0F",
.plaintext = "6BC1BEE22E409F96E93D7E117393172A",
.ciphertext = "bc710d762d070b26361da82b54565e46",
.tag = NULL,
.mode = CRYPT_MODE_CFB
},
// CRYPT_CIPHER_SM4_OFB
// GB/T 17964-2021
{
.id = CRYPT_CIPHER_SM4_OFB,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = "000102030405060708090A0B0C0D0E0F",
.plaintext = "6BC1BEE22E409F96E93D7E117393172A",
.ciphertext = "BC710D762D070B26361DA82B54565E46",
.tag = NULL,
.mode = CRYPT_MODE_OFB
},
// https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38a.pdf
// CRYPT_CIPHER_AES128_CFB
{
.id = CRYPT_CIPHER_AES128_CFB,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c8"
"1c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",
.ciphertext = "3b3fd92eb72dad20333449f8e83cfb4ac8a64537a0b3a93fcde3cdad9f1ce58b2675"
"1f67a3cbb140b1808cf187a4f4dfc04b05357c5d1c0eeac4c66f9ff7f2e6",
.tag = NULL,
.mode = CRYPT_MODE_CFB
},
// CRYPT_CIPHER_AES192_CFB
{
.id = CRYPT_CIPHER_AES192_CFB,
.key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c8"
"1c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",
.ciphertext = "cdc80d6fddf18cab34c25909c99a417467ce7f7f81173621961a2b70171d3d7a2e1e"
"8a1dd59b88b1c8e60fed1efac4c9c05f9f9ca9834fa042ae8fba584b09ff",
.tag = NULL,
.mode = CRYPT_MODE_CFB
},
// CRYPT_CIPHER_AES256_CFB
{
.id = CRYPT_CIPHER_AES256_CFB,
.key = "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c8"
"1c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",
.ciphertext = "dc7e84bfda79164b7ecd8486985d386039ffed143b28b1c832113c6331e5407bdf10"
"132415e54b92a13ed0a8267ae2f975a385741ab9cef82031623d55b1e471",
.tag = NULL,
.mode = CRYPT_MODE_CFB
},
// CRYPT_CIPHER_AES128_OFB
{
.id = CRYPT_CIPHER_AES128_OFB,
.key = "2b7e151628aed2a6abf7158809cf4f3c",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c8"
"1c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",
.ciphertext = "3b3fd92eb72dad20333449f8e83cfb4a7789508d16918f03f53c52dac54ed8259740"
"051e9c5fecf64344f7a82260edcc304c6528f659c77866a510d9c1d6ae5e",
.tag = NULL,
.mode = CRYPT_MODE_OFB
},
// CRYPT_CIPHER_AES192_OFB
{
.id = CRYPT_CIPHER_AES192_OFB,
.key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c8"
"1c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",
.ciphertext = "cdc80d6fddf18cab34c25909c99a4174fcc28b8d4c63837c09e81700c11004018d9a"
"9aeac0f6596f559c6d4daf59a5f26d9f200857ca6c3e9cac524bd9acc92a",
.tag = NULL,
.mode = CRYPT_MODE_OFB
},
// CRYPT_CIPHER_AES256_OFB
{
.id = CRYPT_CIPHER_AES256_OFB,
.key = "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
.aad = NULL,
.iv = "000102030405060708090a0b0c0d0e0f",
.plaintext = "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c8"
"1c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",
.ciphertext = "dc7e84bfda79164b7ecd8486985d38604febdc6740d20b3ac88f6ad82a4fb08d71ab"
"47a086e86eedf39d1c5bba97c4080126141d67f37be8538f5a8be740e484",
.tag = NULL,
.mode = CRYPT_MODE_OFB
}
};
typedef struct {
CRYPT_Data key;
CRYPT_Data iv;
CRYPT_Data aad;
CRYPT_Data plainText;
CRYPT_Data cipherText;
CRYPT_Data tag;
} CIPHER_SELFTEST_DATA;
bool CipherEnc(void *libCtx, const char *attrName, CRYPT_CIPHER_AlgId id, CIPHER_SELFTEST_DATA data)
{
bool ret = false;
CRYPT_EAL_CipherCtx *ctx = NULL;
uint32_t finLen;
uint32_t len = data.cipherText.len;
uint8_t *out = BSL_SAL_Malloc(len);
GOTO_ERR_IF_TRUE(out == NULL, CRYPT_MEM_ALLOC_FAIL);
memset_s(out, len, 0, len);
ctx = CRYPT_EAL_ProviderCipherNewCtx(libCtx, id, attrName);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherInit(ctx, data.key.data, data.key.len, data.iv.data, data.iv.len, true) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherUpdate(ctx, data.plainText.data, data.plainText.len, out, &len) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(data.cipherText.len < len, CRYPT_CMVP_ERR_ALGO_SELFTEST);
finLen = data.cipherText.len - len;
CRYPT_EAL_CipherFinal(ctx, out + len, &finLen);
GOTO_ERR_IF_TRUE(memcmp(out, data.cipherText.data, data.cipherText.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(out);
CRYPT_EAL_CipherFreeCtx(ctx);
return ret;
}
bool CipherDec(void *libCtx, const char *attrName, CRYPT_CIPHER_AlgId id, CIPHER_SELFTEST_DATA data)
{
bool ret = false;
CRYPT_EAL_CipherCtx *ctx = NULL;
uint32_t finLen;
uint32_t len = data.plainText.len;
uint8_t *out = BSL_SAL_Malloc(len);
GOTO_ERR_IF_TRUE(out == NULL, CRYPT_MEM_ALLOC_FAIL);
ctx = CRYPT_EAL_ProviderCipherNewCtx(libCtx, id, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherInit(ctx, data.key.data, data.key.len, data.iv.data, data.iv.len, false) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherUpdate(ctx, data.cipherText.data, data.cipherText.len, out, &len) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(data.plainText.len < len, CRYPT_CMVP_ERR_ALGO_SELFTEST);
finLen = data.plainText.len - len;
CRYPT_EAL_CipherFinal(ctx, out + len, &finLen);
GOTO_ERR_IF_TRUE(memcmp(out, data.plainText.data, data.plainText.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(out);
CRYPT_EAL_CipherFreeCtx(ctx);
return ret;
}
bool AesAeadEnc(void *libCtx, const char *attrName, const CMVP_CIPHER_VECTOR *cipherVec, CIPHER_SELFTEST_DATA data)
{
bool ret = false;
uint64_t msgLen = data.plainText.len;
uint32_t cipherLen = data.cipherText.len;
uint8_t *cipher = NULL;
uint32_t tagLen;
uint8_t *tag = NULL;
uint32_t finLen;
CRYPT_EAL_CipherCtx *ctx = NULL;
cipher = BSL_SAL_Malloc(cipherLen);
GOTO_ERR_IF_TRUE(cipher == NULL, CRYPT_MEM_ALLOC_FAIL);
if (cipherVec->mode == CRYPT_MODE_GCM) {
tagLen = data.tag.len;
tag = BSL_SAL_Malloc(tagLen);
GOTO_ERR_IF_TRUE(tag == NULL, CRYPT_ERR_ALGID);
} else {
tagLen = data.cipherText.len - data.plainText.len;
}
ctx = CRYPT_EAL_ProviderCipherNewCtx(libCtx, cipherVec->id, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherInit(ctx, data.key.data, data.key.len, data.iv.data, data.iv.len, true) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (cipherVec->mode == CRYPT_MODE_CCM) {
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &msgLen, sizeof(msgLen)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, data.aad.data, data.aad.len) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
cipherLen = data.plainText.len;
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherUpdate(ctx, data.plainText.data, data.plainText.len, cipher, &cipherLen) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(data.cipherText.len < cipherLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
finLen = data.cipherText.len - cipherLen;
if (cipherVec->mode != CRYPT_MODE_CCM && cipherVec->mode != CRYPT_MODE_GCM) {
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherFinal(ctx, cipher + cipherLen, &finLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
if (cipherVec->mode == CRYPT_MODE_CCM) {
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, cipher + msgLen, tagLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(cipher, data.cipherText.data, data.cipherText.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
} else {
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(cipher, data.cipherText.data, data.cipherText.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(tag, data.tag.data, data.tag.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
ret = true;
ERR:
BSL_SAL_Free(tag);
BSL_SAL_Free(cipher);
CRYPT_EAL_CipherFreeCtx(ctx);
return ret;
}
bool AesAeadDec(void *libCtx, const char *attrName, const CMVP_CIPHER_VECTOR *cipherVec, CIPHER_SELFTEST_DATA data)
{
bool ret = false;
uint32_t tagLen;
uint8_t *tag = NULL;
uint64_t msgLen = data.plainText.len;
uint32_t plainLen = data.plainText.len;
uint8_t *plain = NULL;
CRYPT_EAL_CipherCtx *ctx = NULL;
plain = BSL_SAL_Malloc(plainLen);
GOTO_ERR_IF_TRUE(plain == NULL, CRYPT_MEM_ALLOC_FAIL);
if (cipherVec->mode == CRYPT_MODE_CCM) {
tagLen = data.cipherText.len - data.plainText.len;
} else {
tagLen = data.tag.len;
}
tag = BSL_SAL_Malloc(tagLen);
GOTO_ERR_IF_TRUE(tag == NULL, CRYPT_MEM_ALLOC_FAIL);
ctx = CRYPT_EAL_ProviderCipherNewCtx(libCtx, cipherVec->id, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherInit(ctx, data.key.data, data.key.len, data.iv.data, data.iv.len, false) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (cipherVec->mode == CRYPT_MODE_CCM) {
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &msgLen, sizeof(msgLen)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, data.aad.data, data.aad.len) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherUpdate(ctx, data.cipherText.data, data.plainText.len, plain, &plainLen) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(data.plainText.len != plainLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(plain, data.plainText.data, data.plainText.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (cipherVec->mode == CRYPT_MODE_CCM) {
GOTO_ERR_IF_TRUE(memcmp(tag, data.cipherText.data + msgLen, tagLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
} else {
GOTO_ERR_IF_TRUE(memcmp(tag, data.tag.data, tagLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
ret = true;
ERR:
BSL_SAL_Free(tag);
BSL_SAL_Free(plain);
CRYPT_EAL_CipherFreeCtx(ctx);
return ret;
}
const CMVP_CIPHER_VECTOR *FindCipherVectorById(CRYPT_CIPHER_AlgId id)
{
uint32_t num = sizeof(CIPHER_VECTOR) / sizeof(CIPHER_VECTOR[0]);
const CMVP_CIPHER_VECTOR *cipherVec = NULL;
for (uint32_t i = 0; i < num; i++) {
if (CIPHER_VECTOR[i].id == id) {
cipherVec = &CIPHER_VECTOR[i];
return cipherVec;
}
}
return NULL;
}
static bool CRYPT_CMVP_SelftestCipherInternal(void *libCtx, const char *attrName, CRYPT_CIPHER_AlgId id)
{
const CMVP_CIPHER_VECTOR *cipherVec = FindCipherVectorById(id);
if (cipherVec == NULL || cipherVec->key == NULL) {
return false;
}
bool ret = false;
CIPHER_SELFTEST_DATA data = {
{ NULL, 0 }, { NULL, 0 }, { NULL, 0 }, { NULL, 0 }, { NULL, 0 }, { NULL, 0 },
};
data.key.data = CMVP_StringsToBins(cipherVec->key, &(data.key.len));
GOTO_ERR_IF_TRUE(data.key.data == NULL, CRYPT_CMVP_COMMON_ERR);
if (cipherVec->iv != NULL) {
data.iv.data = CMVP_StringsToBins(cipherVec->iv, &(data.iv.len));
GOTO_ERR_IF_TRUE(data.iv.data == NULL, CRYPT_CMVP_COMMON_ERR);
}
data.plainText.data = CMVP_StringsToBins(cipherVec->plaintext, &(data.plainText.len));
GOTO_ERR_IF_TRUE(data.plainText.data == NULL, CRYPT_CMVP_COMMON_ERR);
data.cipherText.data = CMVP_StringsToBins(cipherVec->ciphertext, &(data.cipherText.len));
GOTO_ERR_IF_TRUE(data.cipherText.data == NULL, CRYPT_CMVP_COMMON_ERR);
if (cipherVec->aad != NULL) {
data.aad.data = CMVP_StringsToBins(cipherVec->aad, &(data.aad.len));
GOTO_ERR_IF_TRUE(data.aad.data == NULL, CRYPT_CMVP_COMMON_ERR);
}
if (cipherVec->tag != NULL) {
data.tag.data = CMVP_StringsToBins(cipherVec->tag, &(data.tag.len));
GOTO_ERR_IF_TRUE(data.tag.data == NULL, CRYPT_CMVP_COMMON_ERR);
}
if (cipherVec->mode == CRYPT_MODE_CCM || cipherVec->mode == CRYPT_MODE_GCM) {
GOTO_ERR_IF_TRUE(AesAeadEnc(libCtx, attrName, cipherVec, data) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(AesAeadDec(libCtx, attrName, cipherVec, data) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
} else {
GOTO_ERR_IF_TRUE(CipherEnc(libCtx, attrName, id, data) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CipherDec(libCtx, attrName, id, data) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
ret = true;
ERR:
BSL_SAL_Free(data.key.data);
BSL_SAL_Free(data.iv.data);
BSL_SAL_Free(data.cipherText.data);
BSL_SAL_Free(data.plainText.data);
BSL_SAL_Free(data.aad.data);
BSL_SAL_Free(data.tag.data);
return ret;
}
bool CRYPT_CMVP_SelftestCipher(CRYPT_CIPHER_AlgId id)
{
return CRYPT_CMVP_SelftestCipherInternal(NULL, NULL, id);
}
bool CRYPT_CMVP_SelftestProviderCipher(void *libCtx, const char *attrName, CRYPT_CIPHER_AlgId id)
{
return CRYPT_CMVP_SelftestCipherInternal(libCtx, attrName, id);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_cipher.c | C | unknown | 27,208 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
CRYPT_PKEY_ParaId paraId;
const char *p;
const char *q;
const char *g;
const char *xa;
const char *ya;
const char *xb;
const char *yb;
const char *z;
} CMVP_DH_VECTOR;
// https://csrc.nist.gov/projects/cryptographic-algorithm-validation-program/key-management
static const CMVP_DH_VECTOR DH_VECTOR_MODP2048 = {
.paraId = CRYPT_DH_RFC3526_2048,
.p = "f528aa2762df76d7802fea087005d76feb69b7afd9e7fb363715a1b44f09dbda5d06a6"
"3e3d512abe9c6810abba2bfd48cf554513712df25f786265a75f4e1dacaacbbe9e528a"
"6346a8bf38015ecbc523d4e78d738b8852bcd66600dc434286c78f6ccae992568b258b"
"b0d3b503e37e7a956ec1616978c1e7989229e39914ea7c1bea3902e669dfc62368da13"
"7448350c1def54bf3ee2142c065601dfae6bca07e93cc463393cbc483b2c7272553788"
"2ed5b96074f519fc738f5033b87b5edca0ec4a34dc0f84d2fa2c365f691a8fc7dc64bc"
"0839a5813fef9af385c68e952af566f79b0802be9900cf0838032ed249afea05572154"
"0c8961e6300ad5dec651c7",
.q = "fa472bf5133f45b4c7ab14078e1281b487fc4fde1422ba4cafa2a64ea1aad989",
.g = "085c0a0512c241b583d41703edfbfea2a3e863deac68855097707967e097186ef89d05"
"c65227f56b12de6123bac86c3c13d680994bffaf24b2a1ed7f01c108b06593f22f74b4"
"af222b46e5fb89482fbd96f5451c9f45393136ec037aa81a81245459ec018024518394"
"f4d936596dc53c3d8a9f732903719796c045b62fadea9dd1b2fabec1560ddb3b780d96"
"46ad0dd3168c07cc994f79ee804cae07573912511de050d05a0d58b819ec41e7c1205d"
"c7199fc65a6a1a4ffcb4df38d9b6757269003401d84c732385a55174f27d4b493cb710"
"980c3af98be7bcff9467e81792f2d2f9a2f8d5d0ddc9a229790192a194da5b2032f2f0"
"cc23ffbcb2cc166f2128ee",
.xa = "e62d8fdb14fcdc8e4b0c254216eb584a8e79115a294119806ac660cc9d0e3222",
.ya = "815e1c8e64be6786b6c2194506b661199a56c807c6340a83697d3bc75304fbeb91bb15"
"ac7981babba260a653e666b0da8012042a088547f0fbd1ef56d1d1f65ed809ca854513"
"9f57d3ebda3e0f13e7ef19bded4a8dfa204f2457a3d392839dd70bec538a29d7887470"
"9f905ec28740be157696aa862b57ab51ef20033601ff83ba3fb0e80255674e0e6e7269"
"cd85ca10379d418b737d3cdeb5f31fb06f4a141145936a9eec0551b4ba59c59d2b3edd"
"c19ea18978279cf11f21a65a9d2a104cfe6af93fa8a1ccd18b03017a8ab31943993192"
"f794d87bbc273ef9160af954480783cfb6a37ba085503ba258169a8daba71d4c52de7c"
"4e65472223c202ad277e93",
.xb = "561c948be9d0d968cdfc6d27cbfe52cda342f544f56d57f118866326f76e1f70",
.yb = "3c24973b3296269759ce38e2e525c0095d4b5c34be5d13b45b222b8e489c27fb4442f3"
"2cc764665e28a06655c71fb37fd875a921d179551a1e4f2a9054a76cae2a61d3cbec55"
"c3be19853a5409d9ff914b93bc78b8aa1525b908f32419a88d7726ead76a3f8895d630"
"71a9b0a63fe4728d19518d1d08088141b8269f0b0cd77112d476af9efcc7f590af8fc1"
"f9dc5e4c00cd5dfa64a33b2df4db9d8594d87489bea6f6f37958bfb598e5692b81bf11"
"6b60227b6252a6438f049c5c449bab027740f8551bf1ffe25084f231ff646388d009ba"
"22193262029ba19af2643dd679f283212a2d26ad917efe9642c748fceb33fb0a6c132f"
"378dada2cccede086d8a31",
.z = "ec2309a7d238aeb06714c27c1bbbb1b1c5aa3cdddd76a419b1f3704dd3437cd1f2c884"
"3f350d67872ee325973f4e5ace7d406be5de75d9a9120af67e32f0291e77e7a3976249"
"29d63dc0c42ef8f442ce89a39b192fee386ce68301c4b828ea9189798346b60f615dd9"
"639105ffea6ec61ee5e4a7d68ce72bbf1281d6864e30181ce419952a3ef83a9ad7b26f"
"c7292ad745bfb543e5c2ea310a4159e9d660279d12c1e03850e837c01c542a0f59ad61"
"d0731005e8009a3d8406691abb22f5f2e96ae345783c403e59b9e948addbea8ac7d770"
"821044e03f15ae6fc367ddc85ba62a26b4d94d7705f5ecad8aa21b619d0e09f124bee8"
"658a2187f7029107105dbf"
};
// Test vectors sourced from NIST ACVP-Server.
static const CMVP_DH_VECTOR DH_VECTOR_FFDHE2048 = {
.paraId = CRYPT_DH_RFC7919_2048,
.p = NULL,
.q = NULL,
.g = NULL,
.xa = "39983F0CD77A92B44E304AF18C811DB1DB2B820055F1A6CC8B78BFFFA57EB08299664B"
"2CF76C3D5564FEC48C2F2F56AA63ACED5D11AB0B3390C008A94BD4351416DC978F5750"
"410A2B618105EE9847DC9AB12AB39C971522EF97919E57C4DE706614FE20037738F871"
"7895D5BC41458C437DA33F89745D6D742CC29632C0AF0A36CE0B99E0231D4C27833E71"
"60F2687801462D5AA038B89A802B5E1ADF42A1D97C142D5851103E9034AE33B7916397"
"D23BA16B9FF481FC1FD45FE35AA85E27B0E6A58A60A8E37D2A4D237793C4FA4E1E04ED"
"F6090A4331237C9F8C2C19076367762D92491024A5F6B3BA510496154E05B43CE1A722"
"9F793ABD2458095B3D9C78",
.ya = "5FA0CB4D5A976B11442FFDA4569FFF10058E41988C78D0AB6E39B2E226EEFB7C13B9FD"
"65720940118134762CD1ADE1EA83AF64548D8C8BFFA564C8747860FF816AE9C6F13797"
"9FA7C2A4D3E12A3DE68986B43F14CC808E61FAEBAF702FF523795459CFCD19F83563F2"
"5EFC0E57277512FAA8FA23CEF3C8F1D517ABED113FECEE21D926D96BA52A716B5FCDF1"
"87D1ACD999A9CFA951311A042C55C693B20B0DDD98C2F2BBEF67E77FD9E18F0D52045E"
"0B424ED3ECBBD2F34E008FD5C7B482B99CED2A7963DFCA54C5EF9E1FB56F4450B7312C"
"F389D66A696479A6BFEE031D2ECED27969A4061E73331C63B6F21BD7D6E8358FF052F8"
"71DE595DFD57752016D1CA",
.xb = "78502F2AF8969B51D50D2756BAA5EF936FA735B2B2F8423E00D347FF6FB078F14BFA8B"
"2A01A4CBF700C4861A7C65C7EFA026B6AAA7A60B944B09364D29AC3A9C10F6066AA0BB"
"0115BA15E3934A6C9E981B5732E03A32FC23B3B320089F4EA6CFB31C6C7107E99C3063"
"751238D21352BE40B602F94131D9C2D26E3444437D58ED0793D48ACC50749235F26B66"
"837923750E5801F91ED3584A585A0FB213142312A438BE35A309D87009C30F40D49D2E"
"D554F9D6BCBE84F54AB6382E7425FCADAED9D11909FA4624647B963605BC68896A34DA"
"5C7F20447AD19C3381F87F40DC63969855A50E92D4448E432189697F7CAB4191D2B175"
"6BB01FF62D4CA1661F6A33",
.yb = "8CDD3810AA88A5410A5E416A68E9CD31A4542EEC0073A67D12300D3DC1EE5890AFE2DA"
"CA654BFC29C63E1D011C7A52E3DE8D89A3771F43F6921521BB137D25459C90E46F090B"
"FD53B58901109A28F587B96A35828C3464ACF6F80D9646494CF4389FD82BFE4E7AE2BB"
"E5CA2694D7967F56A0E92D43E8C119BD81B7A50516BFA8B39BBEA538AE56556808F4B5"
"C3BAD84A76A5EB373D596DBEF75AB90A49C902615C7386334B70BAE9AC0C4E953DB03B"
"883B64E7E3C3FDD547C6BC3C004D032A57BA40E06DCB0E87016DDADED991FF34FD6ECA"
"06635041DD98C0C4C1DEF942C751DB3F5218BC7C2F6039AF2323F473D3775ED27936FD"
"2E209541C9FAEAE2A75874",
.z = "024E9786943F8AA48E0FC7B2862D620A6DDA720F7CEFB53A38D8DEDC8D8E29737BA62A"
"2E4D04B7E64B2B23396497FBDE5FE803437199C1703C6DA3ED9867FCB358EFD5B98B8B"
"077E608F39DFBF574A89AA5521F78856E04D05E02B525928C437DF2E2AD5D45B0E6E3C"
"5D656CE2434D4D8BB4DCD11496C30615EB1970CA3DE40723518D79E8ED1A07BE59C486"
"134E5075367A74CF1F9DCBFB85BA36E643D4915C481B3129BD6988CB2E7BE441DA257C"
"924C34B431CE048F8F7BC21B601F51D1EA009C77D3E10F3A59196ED40EE2D80699970F"
"76EEC65142617CF427F1386566FDCE92FBA5FE734071B504EED601797589BF7C7F9EAD"
"508A7B5B4915DD477009E1",
};
static bool GetPara(const CMVP_DH_VECTOR *vector, CRYPT_EAL_PkeyPara *para)
{
para->id = CRYPT_PKEY_DH;
para->para.dhPara.p = CMVP_StringsToBins(vector->p, &(para->para.dhPara.pLen));
GOTO_ERR_IF_TRUE(para->para.dhPara.p == NULL, CRYPT_CMVP_COMMON_ERR);
para->para.dhPara.q = CMVP_StringsToBins(vector->q, &(para->para.dhPara.qLen));
GOTO_ERR_IF_TRUE(para->para.dhPara.q == NULL, CRYPT_CMVP_COMMON_ERR);
para->para.dhPara.g = CMVP_StringsToBins(vector->g, &(para->para.dhPara.gLen));
GOTO_ERR_IF_TRUE(para->para.dhPara.g == NULL, CRYPT_CMVP_COMMON_ERR);
return true;
ERR:
return false;
}
static bool GetKey(const CMVP_DH_VECTOR *vector, CRYPT_EAL_PkeyPrv *prv1, CRYPT_EAL_PkeyPub *pub1,
CRYPT_EAL_PkeyPrv *prv2, CRYPT_EAL_PkeyPub *pub2)
{
prv1->id = CRYPT_PKEY_DH;
prv1->key.dhPrv.data = CMVP_StringsToBins(vector->xa, &(prv1->key.dhPrv.len));
GOTO_ERR_IF_TRUE(prv1->key.dhPrv.data == NULL, CRYPT_CMVP_COMMON_ERR);
pub1->id = CRYPT_PKEY_DH;
pub1->key.dhPub.data = CMVP_StringsToBins(vector->ya, &(pub1->key.dhPub.len));
GOTO_ERR_IF_TRUE(pub1->key.dhPub.data == NULL, CRYPT_CMVP_COMMON_ERR);
prv2->id = CRYPT_PKEY_DH;
prv2->key.dhPrv.data = CMVP_StringsToBins(vector->xb, &(prv2->key.dhPrv.len));
GOTO_ERR_IF_TRUE(prv2->key.dhPrv.data == NULL, CRYPT_CMVP_COMMON_ERR);
pub2->id = CRYPT_PKEY_DH;
pub2->key.dhPub.data = CMVP_StringsToBins(vector->yb, &(pub2->key.dhPub.len));
GOTO_ERR_IF_TRUE(pub2->key.dhPub.data == NULL, CRYPT_CMVP_COMMON_ERR);
return true;
ERR:
return false;
}
static bool ComputeShareKey(const CMVP_DH_VECTOR *vector, CRYPT_EAL_PkeyCtx *prv, CRYPT_EAL_PkeyCtx *pub)
{
bool ret = false;
uint8_t *expShare = NULL;
uint8_t *share = NULL;
uint32_t expShareLen;
uint32_t shareLen;
expShare = CMVP_StringsToBins(vector->z, &expShareLen);
GOTO_ERR_IF_TRUE(expShare == NULL, CRYPT_CMVP_COMMON_ERR);
shareLen = expShareLen;
share = BSL_SAL_Malloc(shareLen);
GOTO_ERR_IF_TRUE(share == NULL, CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyComputeShareKey(prv, pub, share, &shareLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(shareLen != expShareLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(share, expShare, expShareLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(expShare);
BSL_SAL_Free(share);
return ret;
}
static void FreeData(CRYPT_EAL_PkeyPara para, CRYPT_EAL_PkeyPrv prv1, CRYPT_EAL_PkeyPub pub1, CRYPT_EAL_PkeyPrv prv2,
CRYPT_EAL_PkeyPub pub2)
{
BSL_SAL_Free(para.para.dhPara.p);
BSL_SAL_Free(para.para.dhPara.q);
BSL_SAL_Free(para.para.dhPara.g);
BSL_SAL_Free(prv1.key.dhPrv.data);
BSL_SAL_Free(pub1.key.dhPub.data);
BSL_SAL_Free(prv2.key.dhPrv.data);
BSL_SAL_Free(pub2.key.dhPub.data);
}
static bool CRYPT_CMVP_SelftestDhInternal(const CMVP_DH_VECTOR *vector, void *libCtx, const char *attrName)
{
bool ret = false;
CRYPT_EAL_PkeyPara para;
para.para.dhPara.p = NULL;
para.para.dhPara.q = NULL;
para.para.dhPara.g = NULL;
CRYPT_EAL_PkeyPrv prv1 = {0};
prv1.key.dhPrv.data = NULL;
CRYPT_EAL_PkeyPub pub1;
pub1.key.dhPub.data = NULL;
CRYPT_EAL_PkeyPrv prv2 = {0};
prv2.key.dhPrv.data = NULL;
CRYPT_EAL_PkeyPub pub2;
pub2.key.dhPub.data = NULL;
CRYPT_EAL_PkeyCtx *pkeyPrv = NULL;
CRYPT_EAL_PkeyCtx *pkeyPub = NULL;
if (vector->paraId == CRYPT_DH_RFC3526_2048) {
GOTO_ERR_IF_TRUE(GetPara(vector, ¶) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
GOTO_ERR_IF_TRUE(GetKey(vector, &prv1, &pub1, &prv2, &pub2) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
pkeyPrv = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_DH, 0, attrName);
pkeyPub = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_DH, 0, attrName);
GOTO_ERR_IF_TRUE(pkeyPrv == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(pkeyPub == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (vector->paraId == CRYPT_DH_RFC3526_2048) {
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPara(pkeyPrv, ¶) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
} else {
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetParaById(pkeyPrv, vector->paraId) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(pkeyPrv, &prv1) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(pkeyPub, &pub2) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(ComputeShareKey(vector, pkeyPrv, pkeyPub) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(pkeyPrv, &prv2) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(pkeyPub, &pub1) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(ComputeShareKey(vector, pkeyPrv, pkeyPub) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
FreeData(para, prv1, pub1, prv2, pub2);
CRYPT_EAL_PkeyFreeCtx(pkeyPrv);
CRYPT_EAL_PkeyFreeCtx(pkeyPub);
return ret;
}
bool CRYPT_CMVP_SelftestDh(void)
{
return CRYPT_CMVP_SelftestDhInternal(&DH_VECTOR_MODP2048, NULL, NULL) &&
CRYPT_CMVP_SelftestDhInternal(&DH_VECTOR_FFDHE2048, NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderDh(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestDhInternal(&DH_VECTOR_MODP2048, libCtx, attrName) &&
CRYPT_CMVP_SelftestDhInternal(&DH_VECTOR_FFDHE2048, libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_dh.c | C | unknown | 13,410 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_rand.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
#define DRBG_PARAM_COUNT 6
typedef enum {
CMVP_DRBG_INSTANTIATE,
CMVP_DRBG_SEED,
CMVP_DRBG_MAX,
} CMVP_DrbgState;
typedef struct {
uint32_t id;
const char *entropy; // EntropyInput
const char *nonce; // Nonce
const char *pers; // PersonalizationString
const char *entropySeed; // EntropyInputReseed
const char *adinSeed; // AdditionalInputReseed
const char *adin1; // AdditionalInput
const char *adin2; // AdditionalInput
const char *retBits; // ReturnedBits
} CMVP_DRBG_VECTOR;
typedef struct {
CMVP_DrbgState state;
CRYPT_RAND_AlgId id;
} CMVP_DRBG_SEEDCTX;
const CMVP_DRBG_VECTOR *g_currentTestVector = NULL;
/**
* Test Vector Execution Order:
* 1. Instantiate
* 2. Reseed
* 3. Generate Random Bits
* 4. Generate Random Bits
* 5. Uninstantiate
* Data Source:
* https://csrc.nist.gov/Projects/cryptographic-algorithm-validation-program/Random-Number-Generators
* NON PR
*/
static const CMVP_DRBG_VECTOR DRBG_VECTOR[] = {
// CRYPT_RAND_SHA1
{
.id = CRYPT_RAND_SHA1,
.entropy = "48a1a97ccc49d7ccf6e378a2f16b0fcd",
.nonce = "b091d2ec12a839fe",
.pers = "3dc16c1add9cac4ebbb0b889e43b9e12",
.entropySeed = "ba5da6791237243fea6050f5b99ecdf5",
.adinSeed = "d123e38e4c97e82994a9717ac6f17c08",
.adin1 = "800bed9729cfade6680dfe53ba0c1e28",
.adin2 = "251e66b9e385ac1c17fb771b5dc76cf2",
.retBits = "a1b2ee86a0f1dab79383133a62279908953a1c9a987760121119cc78b8512bd537a19db973ca397a"
"dd9233786d5d41fffae98059048521e25284bc6fdb97f34e6a127acd410f50682846be569e9a6bc8"
},
// CRYPT_RAND_SHA224
{
.id = CRYPT_RAND_SHA224,
.entropy = "184cbf7f1c462f27fc640ccf2aac1b26174ee41e42dcceaa",
.nonce = "09f9d8acd06aba74b9f849f7",
.pers = "5a5afe330e898ca94fad05b0e6b3f8146f46c90379a0b1eb",
.entropySeed = "b5eb44d3515c74d2cbd28c4ac5edb5fb95846e74e8398ce5",
.adinSeed = "a793fefe0f2ab3e9a0d1ddbc058d78369b03597f44099a81",
.adin1 = "930ef8531a344fef957660cbb401583afa0f016b7023a9db",
.adin2 = "2ee03b7314fb00e1e2616799c144cd58f051cde370588d70",
.retBits = "22b856603db40f1b6d439d5b88fbe4734f7fdee15f4df47dfd418b362f23e48fef0f48f03d1a7b7b"
"0de607c2a8288b1aaa01bc84646c322a88b2351855d7fa1b66b0b12baccbaa5ad6cc71833998f899"
"8712bddf54ab8af329c55791b7576cf36ade4b921009ffe32a8d22ecf4747571"
},
// CRYPT_RAND_SHA256
{
.id = CRYPT_RAND_SHA256,
.entropy = "6c623aea73bc8a59e28c6cd9c7c7ec8ca2e75190bd5dcae5978cf0c199c23f4f",
.nonce = "e55db067a0ed537e66886b7cda02f772",
.pers = "1e59d798810083d1ff848e90b25c9927e3dfb55a0888b0339566a9f9ca7542dc",
.entropySeed = "9ab40164744c7d00c78b4196f6f917ec33d70030a0812cd4606c5a25387568a9",
.adinSeed = "4e8bead7cbba7a7bc9ae1e1617222c4139661347599950e7225d1e2faa5d57f5",
.adin1 = "dcb22a5d9f149858636f3ede2253e419816fb7b1103194451ed6a573a8fe6271",
.adin2 = "8f9d5c78cdabc32e71ac3b3c49239caddf96053250f4fd92056efbd0be487d36",
.retBits = "6e98a3b1f686f6ffa79355c9d8a5ab7f93312159d52659a2298315f10007c71adabc0b5ccb4164c0"
"949fbdb221b43acdb62bed3099596f2d7bd5d0048173dd2360a543b234ab61a441ddb9299af84ca4"
"5c6e618fd521366dbf509d4ec06174da924361d642b107e5564ac1b32340dd2f3158bf4c00bcb4dc"
"f12c6d67af4b74ee"
},
// CRYPT_RAND_SHA384
{
.id = CRYPT_RAND_SHA384,
.entropy = "f411e1feeccf01c0d4bde61ca2384a2640b41e383a055b374e0acfa8170c2f28",
.nonce = "7cf75b960dcd0a0a9d2a4e7e8d5e47d3",
.pers = "25d6dfee3e74d3b6a9f459094203fc76e0e589fa879cc445008c80e3736fc0a9",
.entropySeed = "d222df563773906b875d55dc1aef90337ff59fc3ca5ed0af5e46d306d630c7e3",
.adinSeed = "07a576624662253737789e543734d7c35ded8d74a3b53919b1c28c21a2b5ebc5",
.adin1 = "2561c8591281f0682d3811387d0cdc16c137edfcc9527134212701f73550c572",
.adin2 = "870441d9435f2cbf16f1168f50e32d9b8811be7adc10a5070c5eb993372c5732",
.retBits = "9107af002a8bc3e0f0394eb0db3a801ca73844db0600873d1d576ccfbdd88dfc3eaa101e52e4c4ad"
"9958d9d0e5f1eb555cd0d93ad2745a1302dfead60c42ef28e7211740b1dc694fdf72dd066d1d66a5"
"8aceeb9a8c6a9c67a75326f97b742b85e7abdc853b01bd799bb9f3e8e6b5f2a41919543b17c0da4e"
"4e25f04e1c2859a56466689ab85c46cb9f593abff0f058f7d26f2c09e379e5e0b6e123f24fb9bcfb"
"a9a468dcb38a9577d63251d20f09b8d2b4dad74fb52e1e8dbdde6e0436563d66"
},
// CRYPT_RAND_SHA512
{
.id = CRYPT_RAND_SHA512,
.entropy = "4b23595b0a3640cfabb0ec34df6a613308b0448488a5d9ff99da4278e072eb34",
.nonce = "8e696bffd9ca3a71d2e2f05e600c8364",
.pers = "010ba93ea68a3d4a200e5145859e299c5b5349b7645fb5bbcad687aba7d67313",
.entropySeed = "04de4babdbe143bde99aa4452f9aa43b0a164eb927555c0496aa0fc9328a521c",
.adinSeed = "2b0c7c3efb36b71b917a44086d168313675b426b17c5ab3d0eb6af753f6040e0",
.adin1 = "d0b7d1d12ab15d3bba8f4eba07fee0974838962b247be480683b8e3d4a91033a",
.adin2 = "66c78ca12e45bdca003b49cb6440b977dd85b167e7c803890ed1a73666eaa869",
.retBits = "4008cbd8281dc82fd6c368f650ef2609bb771e80c63d478a77fa938248dcbb8b79e54ead0265f6ff"
"1ebfafe4e387c6e27df9f03e4a5225e86a4436e56ebf03b3be2cfbcb49c89c92ec1dfa5ee445dd4f"
"6f64e02a2423a0b18ebd02eec52f5cc21bc3565e796b3ded6552f1b5a574a201c3b11018222806f9"
"618d23d77fd02db879cf87fe24ed7ba11b3b108b559633db1f95c5121b28011aa4dd20399bd4978e"
"1f8b8880c333a47ff1750679bf28d329347b26d347aae90ee562ae8029579cbe0336e066d6b8ba5e"
"0169fec804c30189a4434c1bf8a5b0a249951d3d89554da38ff0751b8b1fef9ae18a0aa2bc477736"
"d199a06f61d400039a4cc03869bb10ca"
},
// CRYPT_RAND_SM3
{
.id = CRYPT_RAND_SM3,
.entropy = "8c6368232f5cc9da92e5877fd368c5769ecf1f4eaf011a89e11686af8e379895",
.nonce = "8dd1cfbcbd615a47e1298a94ca12f248",
.pers = "c325c1db2ddaa54616b2b804cca6f1a8",
.entropySeed = "5c638a5bc1ffd99fa58b0e2482347f9d5c638a5bc1ffd99fa58b0e2482347f9d",
.adinSeed = "b05a4b1751cd5fb3e583966cf888d44d",
.adin1 = "81b5bbc2ec9e7ae9c2f999ff58d28f2b",
.adin2 = "7af5ca6867e0211baad5b24c6229d6a5",
.retBits = "05a2637f235e86be101ec21b1e75ae26"
},
// CRYPT_RAND_HMAC_SHA1
{
.id = CRYPT_RAND_HMAC_SHA1,
.entropy = "03e7b41c95818eb0b667bfa8a175a824",
.nonce = "66a1e417a9b6b92f",
.pers = "126dded5eb0bc81be37c10bcd9d5f793",
.entropySeed = "d17e98c2e50ee0db00d25c3364451e95",
.adinSeed = "dc596d188e2343802240bc7f5cc60516",
.adin1 = "14c8ec10f5bdde6b9e75898d7f9f03d0",
.adin2 = "31aa842afcc1daa94098241a87d6ddfc",
.retBits = "4739b1bcf87404a2290829bd7a61f0b391a794c71c055c7cc513b28dcb5fdc88645bc9cb490f41fa"
"b134c6b33ce9336571762754343961de671b02a47960b4b4e23c5bfb87dcc19b260b3bcb921ae325"
},
// CRYPT_RAND_HMAC_SHA224
{
.id = CRYPT_RAND_HMAC_SHA224,
.entropy = "96ae702af50c50c7c38818a5133938bd7ce51197fc78e218",
.nonce = "15b6c5a7ff9c0395d764159f",
.pers = "e96554644097e9932585b7f4bb14d101f24c8b0376f38c05",
.entropySeed = "707d5813e5bf47c1b8232b44a007bf7decfef499d758ed53",
.adinSeed = "3f698a5f6f4fe67ef2ddf23bd5a67c1a2df4f3b19425fb85",
.adin1 = "fe1f6a90fc0ed396bca21c0d40a1bb583eb63df78c98adac",
.adin2 = "5942b56148f27dd5388f00caa47ffd4925e854237fe14454",
.retBits = "150b9260ce9aa419fe1860332ae7c9f42d9ada1649679b53f46bc9d20de3431186a54afb5df7b626"
"9cdc05540a93fdd50a2cd3a862372d862841768df02846b057993dd6aa32f874b7220a5a1fd9cb57"
"3d720a54af5715cedfc16f0d9a467735e253b2b1a6e97421fcee1f2d670dec1a"
},
// CRYPT_RAND_HMAC_SHA256
{
.id = CRYPT_RAND_HMAC_SHA256,
.entropy = "cdb0d9117cc6dbc9ef9dcb06a97579841d72dc18b2d46a1cb61e314012bdf416",
.nonce = "d0c0d01d156016d0eb6b7e9c7c3c8da8",
.pers = "6f0fb9eab3f9ea7ab0a719bfa879bf0aaed683307fda0c6d73ce018b6e34faaa",
.entropySeed = "8ec6f7d5a8e2e88f43986f70b86e050d07c84b931bcf18e601c5a3eee3064c82",
.adinSeed = "1ab4ca9014fa98a55938316de8ba5a68c629b0741bdd058c4d70c91cda5099b3",
.adin1 = "16e2d0721b58d839a122852abd3bf2c942a31c84d82fca74211871880d7162ff",
.adin2 = "53686f042a7b087d5d2eca0d2a96de131f275ed7151189f7ca52deaa78b79fb2",
.retBits = "dda04a2ca7b8147af1548f5d086591ca4fd951a345ce52b3cd49d47e84aa31a183e31fbc42a1ff1d"
"95afec7143c8008c97bc2a9c091df0a763848391f68cb4a366ad89857ac725a53b303ddea767be8d"
"c5f605b1b95f6d24c9f06be65a973a089320b3cc42569dcfd4b92b62a993785b0301b3fc45244565"
"6fce22664827b88f"
},
// CRYPT_RAND_HMAC_SHA384
{
.id = CRYPT_RAND_HMAC_SHA384,
.entropy = "c4868db5c46fde0a10008838b5be62c349209fded42fab461b01e11723c8242a",
.nonce = "618faba54acba1e0afd4b27cbd731ed9",
.pers = "135132cf2b8a57554bdc13c68e90dc434353e4f65a4d5ca07c3e0a13c62e7265",
.entropySeed = "d30016b5827dc2bfe4034c6654d69775fe98432b19e3da373213d939d391f54a",
.adinSeed = "a0bbd02f6aa71a06d1642ca2cc7cdc5e8857e431b176bcf1ecd20f041467bd2d",
.adin1 = "93ee30a9e7a0e244aa91da62f2215c7233bdfc415740d2770780cbbad61b9ba2",
.adin2 = "36d922cacca00ae89db8f0c1cae5a47d2de8e61ae09357ca431c28a07907fce1",
.retBits = "2aac4cebed080c68ef0dcff348506eca568180f7370c020deda1a4c9050ce94d4db90fd827165846"
"d6dd6cb2031eec1634b0e7f3e0e89504e34d248e23a8fb31cd32ff39a486946b2940f54c968f96cf"
"c508cd871c84e68458ca7dccabc6dcfb1e9fbef9a47caae14c5239c28686e0fc0942b0c847c9d8d9"
"87970c1c5f5f06eaa8385575dacb1e925c0ed85e13edbb9922083f9bbbb79405411ff5dfe7061568"
"5df1f1e49867d0b6ed69afe8ac5e76ffab6ff3d71b4dae998faf8c7d5bc6ae4d"
},
// CRYPT_RAND_HMAC_SHA512
{
.id = CRYPT_RAND_HMAC_SHA512,
.entropy = "da740cbc36057a8e282ae717fe7dfbb245e9e5d49908a0119c5dbcf0a1f2d5ab",
.nonce = "46561ff612217ba3ff91baa06d4b5440",
.pers = "fc227293523ecb5b1e28c87863626627d958acc558a672b148ce19e2abd2dde4",
.entropySeed = "1d61d4d8a41c3254b92104fd555adae0569d1835bb52657ec7fbba0fe03579c5",
.adinSeed = "b9ed8e35ad018a375b61189c8d365b00507cb1b4510d21cac212356b5bbaa8b2",
.adin1 = "b7998998eaf9e5d34e64ff7f03de765b31f407899d20535573e670c1b402c26a",
.adin2 = "2089d49d63e0c4df58879d0cb1ba998e5b3d1a7786b785e7cf13ca5ea5e33cfd",
.retBits = "5b70f3e4da95264233efbab155b828d4e231b67cc92757feca407cc9615a660871cb07ad1a2e9a99"
"412feda8ee34dc9c57fa08d3f8225b30d29887d20907d12330fffd14d1697ba0756d37491b0a8814"
"106e46c8677d49d9157109c402ad0c247a2f50cd5d99e538c850b906937a05dbb8888d984bc77f6c"
"a00b0e3bc97b16d6d25814a54aa12143afddd8b2263690565d545f4137e593bb3ca88a37b0aadf79"
"726b95c61906257e6dc47acd5b6b7e4b534243b13c16ad5a0a1163c0099fce43f428cd27c3e6463c"
"f5e9a9621f4b3d0b3d4654316f4707675df39278d5783823049477dcce8c57fdbd576711c91301e9"
"bd6bb0d3e72dc46d480ed8f61fd63811"
},
// CRYPT_RAND_AES128_CTR
{
.id = CRYPT_RAND_AES128_CTR,
.entropy = "289e5c8283cbd7dbe707255cb3cf2907d8a5ce5b347314966f9b2bebb1a1e200",
.nonce = NULL,
.pers = "7f7b59f23510b976fe155d047525c94e2dacb30d77ac8b09281544dd815d5293",
.entropySeed = "98c522028f36fc6b85a8f3c003efd4b130dd90180ec81cf7c67d4c53d10f0022",
.adinSeed = "f7a0378328d939f0f8521e39409d7175d87319c7597a9050414f7adc392a328d",
.adin1 = "19c286f5b36194d1cc62c0188140bc9d61d2a9c5d88bb5aebc224bfb04dfca83",
.adin2 = "820650c3201d347f5b20d3d25d1c8c7bef4d9f66a5a04c7dd9d669e95182a0c4",
.retBits = "79a79d44edada58e3fc12a4e36ae900eeace290265f01262f40f2958a70dcbd4d4185f708c088ede"
"7ff8c8375f44f4012f2512d38328a5df171a17029d90f185"
},
// CRYPT_RAND_AES192_CTR
{
.id = CRYPT_RAND_AES192_CTR,
.entropy = "4b58271b116237eedd4e9ff9360382a59f3e2a173d860f2bbd8b2bace142b2395c67cf5a513f06f3",
.nonce = NULL,
.pers = "cf76c16cd5d270707ea9acc39744db69bfac63e566256fd6917bf9819679840f3fea2aa535d8df01",
.entropySeed = "1867f371a345eef98b2d70fc1960397892645b7b29a4ead252e8835e0b600618a9bd6ff99785d890",
.adinSeed = "6d44839aff8b7165deebd489ad088ecb7dcec11c32b1e747dba8f0e8a0b89f74a84ea8a05586fe9e",
.adin1 = "42248fce0994e0e63504209d629a6943eb3e2ad512f03f79cbd5102928392bce1cacbba056ac6ca9",
.adin2 = "bd529b600273329423a58d6f8a12be0f17989a02e73e347bc7d49d9169337a6cff7c07e8a807a80a",
.retBits = "02486d32cd55954f406ba55705f1460d384439592dede81a84fda221fd45c0d651d67ec4a81a8b40"
"4151a643f331ad051cb004352289de37bca71e8cc0a6aeab"
},
// CRYPT_RAND_AES256_CTR
{
.id = CRYPT_RAND_AES256_CTR,
.entropy = "ae7ebe062971f5eb32e5b21444750785de816595ad2cbe80a209c8f8ab04b5468166de8c6ae522d8"
"f10b56386a3b424f",
.nonce = NULL,
.pers = "55860dae57fcac297087c137efb796878a75868f6e7681114e9b73ed0c67e3c62bfc9f5d77e8caa5"
"9bcdb223f4ffd247",
.entropySeed = "a42407931bfeca70e6ee5dd197021a129525051c07468e8b25587c5ad50abe9204e882fe847b8fd4"
"7cf7b4360e5aa034",
.adinSeed = "ee4c88d1eb05f4853663eada501d2fc4b4984b283a88db579af2113031e03d9bc570de943dd16891"
"8f3ba8065581fea7",
.adin1 = "4b4b03ef19b0f259dca2b3ee3ae4cd86c3895a784b3d8eee043a2003c08289f8fffdad141e6b1ab2"
"174d8d5d79c1e581",
.adin2 = "3062b33f116b46e20fe3c354726ae9b2a3a4c51922c8107863cb86f1f0bdad7554075659d91c371e"
"2b11b1e8106a1ed5",
.retBits = "0d270518baeafac160ff1cb28c11ef68712c764c0c01674e6c9ca2cc9c7e0e8accfd3c753635ee07"
"0081eee7628af6187fbc2854b3c204461a796cf3f3fcb092"
},
// CRYPT_RAND_AES128_CTR_DF
{
.id = CRYPT_RAND_AES128_CTR_DF,
.entropy = "e14ed7064a97814dd326b9a05bc44543",
.nonce = "876240c1f7de3dba",
.pers = "26ccf56848a048721d0aad87d6fc65f0",
.entropySeed = "7ec4ac660fa0bbfa66ac3802e511901f",
.adinSeed = "8835d28e7f85a4e95087bdd1bb7ad57e",
.adin1 = "2a9bd50bbb20fefe24649f5f80eede66",
.adin2 = "f7ce3d5c6c381e56b25410c6909c1074",
.retBits = "d2f3130d309bed1da65545b9d793e035fd2564303d1fdcfb6c7fee019500d9f5d434fab2d3c8d15e"
"39a25f965aaa804c7141407e90c4a86a6c8d303ce83bfb34"
},
// CRYPT_RAND_AES192_CTR_DF
{
.id = CRYPT_RAND_AES192_CTR_DF,
.entropy = "c4b1e6a99587eacd7ec8517f40f9433ca432cea8686433f0",
.nonce = "d03a29e548e58ca7cbf0ac707b1464e3",
.pers = "0daaead21779b2a428d2b7fb12d9ab8316899edbe26b5460de1549c99e4781c9",
.entropySeed = "2229144c1b4efb79ab5fe079cda26bc33acbb2a0a87f642c",
.adinSeed = "f116a683ca485fda846a598b8d9b079e78c2828286ad530bf01f693cc8af9f84",
.adin1 = "7c89de353298935bd26aa18517355313df0630da5f45ea0240e809179363080b",
.adin2 = "e978b8fe56afc908bed129a46d57a8698d66034d4dbcc7aba3a33d5796fb7559",
.retBits = "8ce7e9589c2975fd6989a450aa65da9114e515777c97351da037ccb72d4987eb69c680411724ed60"
"2e6ac76cd2d085725616c92777a4664d43a59c3ae9946134"
},
// CRYPT_RAND_AES256_CTR_DF
{
.id = CRYPT_RAND_AES256_CTR_DF,
.entropy = "174b46250051a9e3d80c56ae7163dafe7e54481a56cafd3b8625f99bbb29c442",
.nonce = "98ffd99c466e0e94a45da7e0e82dbc6b",
.pers = "7095268e99938b3e042734b9176c9aa051f00a5f8d2a89ada214b89beef18ebf",
.entropySeed = "e88be1967c5503f65d23867bbc891bd679db03b4878663f6c877592df25f0d9a",
.adinSeed = "cdf6ad549e45b6aa5cd67d024931c33cd133d52d5ae500c3015020beb30da063",
.adin1 = "c7228e90c62f896a09e11684530102f926ec90a3255f6c21b857883c75800143",
.adin2 = "76a94f224178fe4cbf9e2b8acc53c9dc3e50bb613aac8936601453cda3293b17",
.retBits = "1a6d8dbd642076d13916e5e23038b60b26061f13dd4e006277e0268698ffb2c87e453bae1251631a"
"c90c701a9849d933995e8b0221fe9aca1985c546c2079027"
},
// CRYPT_RAND_SM4_CTR_DF
{
.id = CRYPT_RAND_SM4_CTR_DF,
.entropy = "8c6368232f5cc9da92e5877fd368c5769ecf1f4eaf011a89e11686af8e379895",
.nonce = "8dd1cfbcbd615a47e1298a94ca12f248",
.pers = "c325c1db2ddaa54616b2b804cca6f1a8",
.entropySeed = "5c638a5bc1ffd99fa58b0e2482347f9d5c638a5bc1ffd99fa58b0e2482347f9d",
.adinSeed = "b05a4b1751cd5fb3e583966cf888d44d",
.adin1 = "81b5bbc2ec9e7ae9c2f999ff58d28f2b",
.adin2 = "7af5ca6867e0211baad5b24c6229d6a5",
.retBits = "5e9a44ce51ee802f2fc49335d8b4588b"
},
};
static int32_t CMVP_DrbgGetEntropy(void *ctx, CRYPT_Data *entropy, uint32_t strength, CRYPT_Range *lenRange)
{
CMVP_DRBG_SEEDCTX *seedCtx = (CMVP_DRBG_SEEDCTX *)ctx;
const CMVP_DRBG_VECTOR *vector = g_currentTestVector;
GOTO_ERR_IF_TRUE(vector == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(vector->entropy == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (seedCtx->state == CMVP_DRBG_INSTANTIATE) {
entropy->data = CMVP_StringsToBins(vector->entropy, &(entropy->len));
GOTO_ERR_IF_TRUE(entropy->data == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
seedCtx->state = CMVP_DRBG_SEED;
} else if (seedCtx->state == CMVP_DRBG_SEED) {
entropy->data = CMVP_StringsToBins(vector->entropySeed, &(entropy->len));
GOTO_ERR_IF_TRUE(entropy->data == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
seedCtx->state = CMVP_DRBG_MAX;
}
(void)strength;
(void)lenRange;
return CRYPT_SUCCESS;
ERR:
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
static void CMVP_DrbgCleanData(void *ctx, CRYPT_Data *data)
{
BSL_SAL_Free(data->data);
data->data = NULL;
data->len = 0;
(void)ctx;
}
static int32_t CMVP_DrbgGetNonce(void *ctx, CRYPT_Data *nonce, uint32_t strength, CRYPT_Range *lenRange)
{
(void)ctx;
uint8_t *data = NULL;
uint32_t dataLen;
const CMVP_DRBG_VECTOR *vector = g_currentTestVector;
GOTO_ERR_IF_TRUE(vector == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(vector->nonce == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
data = CMVP_StringsToBins(vector->nonce, &dataLen);
GOTO_ERR_IF_TRUE(data == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
nonce->data = data;
nonce->len = dataLen;
(void)strength;
(void)lenRange;
return CRYPT_SUCCESS;
ERR:
BSL_SAL_Free(data);
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
static CRYPT_EAL_RndCtx *CMVP_DrbgInit(void *libCtx, const char *attrName, const CMVP_DRBG_VECTOR *drbgVec,
CMVP_DRBG_SEEDCTX *seedCtx)
{
CRYPT_EAL_RndCtx *ctx = NULL;
uint8_t *pers = NULL;
uint32_t persLen;
CRYPT_RandSeedMethod method;
const CMVP_DRBG_VECTOR *vector = drbgVec;
GOTO_ERR_IF_TRUE(vector->pers == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
pers = CMVP_StringsToBins(vector->pers, &persLen);
GOTO_ERR_IF_TRUE(pers == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
method.getEntropy = CMVP_DrbgGetEntropy;
method.cleanEntropy = CMVP_DrbgCleanData;
method.getNonce = CMVP_DrbgGetNonce;
method.cleanNonce = CMVP_DrbgCleanData;
int32_t index = 0;
BSL_Param param[DRBG_PARAM_COUNT] = {0};
(void)BSL_PARAM_InitValue(¶m[index++], CRYPT_PARAM_RAND_SEEDCTX, BSL_PARAM_TYPE_CTX_PTR,
seedCtx, 0);
(void)BSL_PARAM_InitValue(¶m[index++], CRYPT_PARAM_RAND_SEED_GETENTROPY, BSL_PARAM_TYPE_FUNC_PTR,
method.getEntropy, 0);
(void)BSL_PARAM_InitValue(¶m[index++], CRYPT_PARAM_RAND_SEED_CLEANENTROPY, BSL_PARAM_TYPE_FUNC_PTR,
method.cleanEntropy, 0);
(void)BSL_PARAM_InitValue(¶m[index++], CRYPT_PARAM_RAND_SEED_GETNONCE, BSL_PARAM_TYPE_FUNC_PTR,
method.getNonce, 0);
(void)BSL_PARAM_InitValue(¶m[index++], CRYPT_PARAM_RAND_SEED_CLEANNONCE, BSL_PARAM_TYPE_FUNC_PTR,
method.cleanNonce, 0);
ctx = CRYPT_EAL_ProviderDrbgNewCtx(libCtx, drbgVec->id, attrName, param);
GOTO_ERR_IF_TRUE(ctx == NULL,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_DrbgInstantiate(ctx, pers, persLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
BSL_SAL_Free(pers);
return ctx;
ERR:
CRYPT_EAL_DrbgDeinit(ctx);
BSL_SAL_Free(pers);
return NULL;
}
static void FreeData(uint8_t *rand, uint8_t *expectRand, uint8_t *adinSeed, uint8_t *adin1, uint8_t *adin2)
{
BSL_SAL_Free(rand);
BSL_SAL_Free(expectRand);
BSL_SAL_Free(adinSeed);
BSL_SAL_Free(adin1);
BSL_SAL_Free(adin2);
}
static uint8_t *ExecDrbg(CRYPT_EAL_RndCtx *ctx, uint32_t randLen, uint8_t *adin1, uint32_t adin1Len,
uint8_t *adin2, uint32_t adin2Len)
{
uint8_t *rand = NULL;
rand = BSL_SAL_Malloc(randLen);
GOTO_ERR_IF_TRUE(rand == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_DrbgbytesWithAdin(ctx, rand, randLen, adin1, adin1Len) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_DrbgbytesWithAdin(ctx, rand, randLen, adin2, adin2Len) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
return rand;
ERR:
BSL_SAL_Free(rand);
return NULL;
}
static bool GetData(const CMVP_DRBG_VECTOR *drbgVec, CRYPT_Data *expectRand, CRYPT_Data *adinSeed, CRYPT_Data *adin1,
CRYPT_Data *adin2)
{
expectRand->data = CMVP_StringsToBins(drbgVec->retBits, &(expectRand->len));
GOTO_ERR_IF_TRUE(expectRand->data == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
adin1->data = CMVP_StringsToBins(drbgVec->adin1, &(adin1->len));
GOTO_ERR_IF_TRUE(adin1->data == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
adin2->data = CMVP_StringsToBins(drbgVec->adin2, &(adin2->len));
GOTO_ERR_IF_TRUE(adin2->data == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
adinSeed->data = CMVP_StringsToBins(drbgVec->adinSeed, &(adinSeed->len));
GOTO_ERR_IF_TRUE(adinSeed->data == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
return true;
ERR:
return false;
}
const CMVP_DRBG_VECTOR *FindDrbgVectorById(CRYPT_RAND_AlgId id)
{
uint32_t num = sizeof(DRBG_VECTOR) / sizeof(DRBG_VECTOR[0]);
const CMVP_DRBG_VECTOR *drbgVec = NULL;
for (uint32_t i = 0; i < num; i++) {
if (DRBG_VECTOR[i].id == id) {
drbgVec = &DRBG_VECTOR[i];
return drbgVec;
}
}
return NULL;
}
static bool CRYPT_CMVP_SelftestDrbgInternal(void *libCtx, const char *attrName, CRYPT_RAND_AlgId id)
{
bool ret = false;
CRYPT_EAL_RndCtx *ctx = NULL;
uint8_t *rand = NULL;
CRYPT_Data expectRand = { NULL, 0 };
CRYPT_Data adinSeed = { NULL, 0 };
CRYPT_Data adin1 = { NULL, 0 };
CRYPT_Data adin2 = { NULL, 0 };
CMVP_DRBG_SEEDCTX seedCtx = { CMVP_DRBG_INSTANTIATE, id };
const CMVP_DRBG_VECTOR *drbgVec = FindDrbgVectorById(id);
if (drbgVec == NULL || drbgVec->entropy == NULL) {
return false;
}
g_currentTestVector = drbgVec;
GOTO_ERR_IF_TRUE(!GetData(drbgVec, &expectRand, &adinSeed, &adin1, &adin2), CRYPT_CMVP_ERR_ALGO_SELFTEST);
ctx = CMVP_DrbgInit(libCtx, attrName, drbgVec, &seedCtx);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_DrbgSeedWithAdin(ctx, adinSeed.data, adinSeed.len) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
// 2: One byte and two characters
rand = ExecDrbg(ctx, (uint32_t)strlen(drbgVec->retBits) / 2, adin1.data, adin1.len, adin2.data, adin2.len);
GOTO_ERR_IF_TRUE(rand == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(rand, expectRand.data, expectRand.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
CRYPT_EAL_DrbgDeinit(ctx);
FreeData(rand, expectRand.data, adinSeed.data, adin1.data, adin2.data);
return ret;
}
bool CRYPT_CMVP_SelftestDrbg(CRYPT_RAND_AlgId id)
{
return CRYPT_CMVP_SelftestDrbgInternal(NULL, NULL, id);
}
bool CRYPT_CMVP_SelftestProviderDrbg(void *libCtx, const char *attrName, CRYPT_RAND_AlgId id)
{
return CRYPT_CMVP_SelftestDrbgInternal(libCtx, attrName, id);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_drbg.c | C | unknown | 25,307 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_bn.h"
#include "crypt_encode_internal.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_util_rand.h"
#include "bsl_sal.h"
#define BITS_OF_BYTE 8
typedef struct {
const char *p;
const char *q;
const char *g;
const char *msg;
const char *x; // The private key.
const char *y;
const char *k;
const char *r;
const char *s;
CRYPT_MD_AlgId mdId;
} CMVP_DSA_VECTOR;
// https://www.rfc-editor.org/rfc/rfc6979#page-27
static const CMVP_DSA_VECTOR DSA_VECTOR = {
.p = "a8adb6c0b4cf9588012e5deff1a871d383e0e2a85b5e8e03d814fe13a059705e"
"663230a377bf7323a8fa117100200bfd5adf857393b0bbd67906c081e585410e"
"38480ead51684dac3a38f7b64c9eb109f19739a4517cd7d5d6291e8af20a3fbf"
"17336c7bf80ee718ee087e322ee41047dabefbcc34d10b66b644ddb3160a28c0"
"639563d71993a26543eadb7718f317bf5d9577a6156561b082a10029cd44012b"
"18de6844509fe058ba87980792285f2750969fe89c2cd6498db3545638d5379d"
"125dccf64e06c1af33a6190841d223da1513333a7c9d78462abaab31b9f96d5f"
"34445ceb6309f2f6d2c8dde06441e87980d303ef9a1ff007e8be2f0be06cc15f",
.q = "e71f8567447f42e75f5ef85ca20fe557ab0343d37ed09edc3f6e68604d6b9dfb",
.g = "5ba24de9607b8998e66ce6c4f812a314c6935842f7ab54cd82b19fa104abfb5d"
"84579a623b2574b37d22ccae9b3e415e48f5c0f9bcbdff8071d63b9bb956e547"
"af3a8df99e5d3061979652ff96b765cb3ee493643544c75dbe5bb39834531952"
"a0fb4b0378b3fcbb4c8b5800a5330392a2a04e700bb6ed7e0b85795ea38b1b96"
"2741b3f33b9dde2f4ec1354f09e2eb78e95f037a5804b6171659f88715ce1a9b"
"0cc90c27f35ef2f10ff0c7c7a2bb0154d9b8ebe76a3d764aa879af372f4240de"
"8347937e5a90cec9f41ff2f26b8da9a94a225d1a913717d73f10397d2183f1ba"
"3b7b45a68f1ff1893caf69a827802f7b6a48d51da6fbefb64fd9a6c5b75c4561",
.msg = "4e3a28bcf90d1d2e75f075d9fbe55b36c5529b17bc3a9ccaba6935c9e2054825"
"5b3dfae0f91db030c12f2c344b3a29c4151c5b209f5e319fdf1c23b190f64f1f"
"e5b330cb7c8fa952f9d90f13aff1cb11d63181da9efc6f7e15bfed4862d1a62c"
"7dcf3ba8bf1ff304b102b1ec3f1497dddf09712cf323f5610a9d10c3d9132659",
.x = "446969025446247f84fdea74d02d7dd13672b2deb7c085be11111441955a377b",
.y = "5a55dceddd1134ee5f11ed85deb4d634a3643f5f36dc3a70689256469a0b651a"
"d22880f14ab85719434f9c0e407e60ea420e2a0cd29422c4899c416359dbb1e5"
"92456f2b3cce233259c117542fd05f31ea25b015d9121c890b90e0bad033be13"
"68d229985aac7226d1c8c2eab325ef3b2cd59d3b9f7de7dbc94af1a9339eb430"
"ca36c26c46ecfa6c5481711496f624e188ad7540ef5df26f8efacb820bd17a1f"
"618acb50c9bc197d4cb7ccac45d824a3bf795c234b556b06aeb9291734532520"
"84003f69fe98045fe74002ba658f93475622f76791d9b2623d1b5fff2cc16844"
"746efd2d30a6a8134bfc4c8cc80a46107901fb973c28fc553130f3286c1489da",
.k = "117a529e3fdfc79843a5a4c07539036b865214e014b4928c2a31f47bf62a4fdb",
.r = "633055e055f237c38999d81c397848c38cce80a55b649d9e7905c298e2a51447",
.s = "2bbf68317660ec1e4b154915027b0bc00ee19cfc0bf75d01930504f2ce10a8b0",
.mdId = CRYPT_MD_SHA256
};
static bool GetPkey(void *libCtx, const char *attrName, CRYPT_EAL_PkeyCtx **pkeyPrv, CRYPT_EAL_PkeyCtx **pkeyPub,
CRYPT_EAL_PkeyPara *para, CRYPT_EAL_PkeyPub *pub, CRYPT_EAL_PkeyPrv *prv)
{
*pkeyPrv = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_DSA, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPrv == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
*pkeyPub = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_DSA, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPub == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
para->para.dsaPara.p = CMVP_StringsToBins(DSA_VECTOR.p, &(para->para.dsaPara.pLen));
GOTO_ERR_IF_TRUE(para->para.dsaPara.p == NULL, CRYPT_CMVP_COMMON_ERR);
para->para.dsaPara.q = CMVP_StringsToBins(DSA_VECTOR.q, &(para->para.dsaPara.qLen));
GOTO_ERR_IF_TRUE(para->para.dsaPara.q == NULL, CRYPT_CMVP_COMMON_ERR);
para->para.dsaPara.g = CMVP_StringsToBins(DSA_VECTOR.g, &(para->para.dsaPara.gLen));
GOTO_ERR_IF_TRUE(para->para.dsaPara.g == NULL, CRYPT_CMVP_COMMON_ERR);
prv->key.dsaPrv.data = CMVP_StringsToBins(DSA_VECTOR.x, &(prv->key.dsaPrv.len));
GOTO_ERR_IF_TRUE(prv->key.dsaPrv.data == NULL, CRYPT_CMVP_COMMON_ERR);
pub->key.dsaPub.data = CMVP_StringsToBins(DSA_VECTOR.y, &(pub->key.dsaPub.len));
GOTO_ERR_IF_TRUE(pub->key.dsaPub.data == NULL, CRYPT_CMVP_COMMON_ERR);
para->id = CRYPT_PKEY_DSA;
pub->id = CRYPT_PKEY_DSA;
prv->id = CRYPT_PKEY_DSA;
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPara(*pkeyPrv, para) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPara(*pkeyPub, para) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(*pkeyPrv, prv) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(*pkeyPub, pub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
return true;
ERR:
return false;
}
static int32_t TestVectorRandom(uint8_t *r, uint32_t rLen)
{
uint8_t *rand = NULL;
uint32_t randLen;
rand = CMVP_StringsToBins(DSA_VECTOR.k, &randLen);
if (rand == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
if (randLen < rLen) {
BSL_SAL_Free(rand);
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
for (uint32_t i = 0; i < randLen; i++) {
r[i] = rand[i];
}
BSL_SAL_Free(rand);
return 0;
}
static int32_t SignEncode(const char *signR, const char *signS, uint8_t *vectorSign, uint32_t *vectorSignLen)
{
int ret = CRYPT_CMVP_ERR_ALGO_SELFTEST;
BN_BigNum *bnR = NULL;
BN_BigNum *bnS = NULL;
uint8_t *r = NULL;
uint8_t *s = NULL;
uint32_t rLen, sLen;
r = CMVP_StringsToBins(signR, &rLen);
GOTO_ERR_IF_TRUE(r == NULL, CRYPT_CMVP_COMMON_ERR);
s = CMVP_StringsToBins(signS, &sLen);
GOTO_ERR_IF_TRUE(s == NULL, CRYPT_CMVP_COMMON_ERR);
bnR = BN_Create(rLen * BITS_OF_BYTE);
bnS = BN_Create(sLen * BITS_OF_BYTE);
GOTO_ERR_IF_TRUE(BN_Bin2Bn(bnR, r, rLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(BN_Bin2Bn(bnS, s, sLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = CRYPT_EAL_EncodeSign(bnR, bnS, vectorSign, vectorSignLen);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = CRYPT_SUCCESS;
ERR:
BSL_SAL_Free(r);
BSL_SAL_Free(s);
BN_Destroy(bnR);
BN_Destroy(bnS);
return ret;
}
static void FreeData(CRYPT_EAL_PkeyPara para, CRYPT_EAL_PkeyPub pub, CRYPT_EAL_PkeyPrv prv, uint8_t *msg, uint8_t *sign)
{
BSL_SAL_Free(para.para.dsaPara.p);
BSL_SAL_Free(para.para.dsaPara.q);
BSL_SAL_Free(para.para.dsaPara.g);
BSL_SAL_Free(msg);
BSL_SAL_Free(pub.key.dsaPub.data);
BSL_SAL_Free(prv.key.dsaPrv.data);
BSL_SAL_Free(sign);
}
static bool CRYPT_CMVP_SelftestDsaInternal(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *msg = NULL;
uint8_t *sign = NULL;
uint8_t *signVec = NULL;
uint32_t msgLen, signLen;
uint32_t signVecLen = 0;
CRYPT_EAL_PkeyCtx *pkeyPrv = NULL;
CRYPT_EAL_PkeyCtx *pkeyPub = NULL;
CRYPT_EAL_PkeyPara para = { 0 };
CRYPT_EAL_PkeyPub pub = { 0 };
CRYPT_EAL_PkeyPrv prv = { 0 };
CRYPT_EAL_RandFunc func = CRYPT_RandRegistGet();
CRYPT_EAL_RandFuncEx funcEx = CRYPT_RandRegistExGet();
CRYPT_RandRegistEx(NULL);
msg = CMVP_StringsToBins(DSA_VECTOR.msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(!GetPkey(libCtx, attrName, &pkeyPrv, &pkeyPub, ¶, &pub, &prv), CRYPT_CMVP_ERR_ALGO_SELFTEST);
signLen = CRYPT_EAL_PkeyGetSignLen(pkeyPrv);
sign = BSL_SAL_Malloc(signLen);
signVecLen = signLen;
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_MEM_ALLOC_FAIL);
signVec = BSL_SAL_Malloc(signLen);
GOTO_ERR_IF_TRUE(signVec == NULL, CRYPT_MEM_ALLOC_FAIL);
// regist rand function
CRYPT_RandRegist(TestVectorRandom);
// sign
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySign(pkeyPrv, DSA_VECTOR.mdId, msg, msgLen, sign, &signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
// compare the signature
GOTO_ERR_IF_TRUE(SignEncode(DSA_VECTOR.r, DSA_VECTOR.s, signVec, &signVecLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(signLen != signVecLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(signVec, sign, signLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
// verify
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyVerify(pkeyPub, DSA_VECTOR.mdId, msg, msgLen, sign, signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
FreeData(para, pub, prv, msg, sign);
BSL_SAL_Free(signVec);
CRYPT_EAL_PkeyFreeCtx(pkeyPrv);
CRYPT_EAL_PkeyFreeCtx(pkeyPub);
CRYPT_RandRegist(func);
CRYPT_RandRegistEx(funcEx);
return ret;
}
bool CRYPT_CMVP_SelftestDsa(void)
{
return CRYPT_CMVP_SelftestDsaInternal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderDsa(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestDsaInternal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_dsa.c | C | unknown | 9,983 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "securec.h"
#include "bsl_sal.h"
typedef struct {
const char *bobD;
const char *bobX;
const char *bobY;
const char *aliceD;
const char *aliceX;
const char *aliceY;
const char *shareKey;
int32_t curveId;
CRYPT_MD_AlgId mdId;
} CMVP_EcdhVector;
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/keymgmt/KASTestVectorsECC2016.zip
static const CMVP_EcdhVector ECDH_VECTOR = {
.bobD = "d58751997b3a551ccdc6f507bf6ab87e2be7f8267067a455a5815a54",
.bobX = "c7893ced15c3009b93cb0abeaea2ede308b67fbbd902c6c5d94c24a4",
.bobY = "858afc2edd61fcefef3469dd5a004e74a3c727d16498a9408a8e3224",
.aliceD = "e935434303d842605d07112b3b7789ccbe4c6d987db5fa15ea1cdadb",
.aliceX = "784028a2246950401ec81f8e4e03fd3765c4da4d45eba652ed5ba2b5",
.aliceY = "d071c32634bcf058f072493b6943453a0bd117f5ee5c5866f037f6ab",
.shareKey = "dfd0570d4ae5c9f690c757aead04f7e14758fdc4ee05d8f0d089b91a",
.curveId = CRYPT_ECC_NISTP224,
.mdId = CRYPT_MD_SHA224
};
static bool GetPkey(void *libCtx, const char *attrName, bool isBob, CRYPT_EAL_PkeyCtx **pkeyPrv,
CRYPT_EAL_PkeyCtx **pkeyPub, CRYPT_EAL_PkeyPub *pub, CRYPT_EAL_PkeyPrv *prv)
{
bool ret = false;
uint8_t *x = NULL;
uint8_t *y = NULL;
uint32_t xLen, yLen;
*pkeyPrv = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_ECDH, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPrv == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
*pkeyPub = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_ECDH, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPub == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
prv->id = CRYPT_PKEY_ECDH;
if (isBob == true) {
prv->key.eccPrv.data = CMVP_StringsToBins(ECDH_VECTOR.bobD, &(prv->key.eccPrv.len));
} else {
prv->key.eccPrv.data = CMVP_StringsToBins(ECDH_VECTOR.aliceD, &(prv->key.eccPrv.len));
}
GOTO_ERR_IF_TRUE(prv->key.eccPrv.data == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetParaById(*pkeyPrv, ECDH_VECTOR.curveId) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(*pkeyPrv, prv) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
pub->id = CRYPT_PKEY_ECDH;
if (isBob == true) {
x = CMVP_StringsToBins(ECDH_VECTOR.bobX, &xLen);
y = CMVP_StringsToBins(ECDH_VECTOR.bobY, &yLen);
} else {
x = CMVP_StringsToBins(ECDH_VECTOR.aliceX, &xLen);
y = CMVP_StringsToBins(ECDH_VECTOR.aliceY, &yLen);
}
GOTO_ERR_IF_TRUE(x == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(y == NULL, CRYPT_CMVP_COMMON_ERR);
pub->key.eccPub.len = xLen + yLen + 1;
pub->key.eccPub.data = BSL_SAL_Malloc(pub->key.eccPub.len);
GOTO_ERR_IF_TRUE(pub->key.eccPub.data == NULL, CRYPT_MEM_ALLOC_FAIL);
pub->key.eccPub.data[0] = 0x04; // CRYPT_POINT_UNCOMPRESSED标记头
GOTO_ERR_IF_TRUE(memcpy_s(pub->key.eccPub.data + 1, pub->key.eccPub.len, x, xLen) != EOK, CRYPT_SECUREC_FAIL);
GOTO_ERR_IF_TRUE(
memcpy_s(pub->key.eccPub.data + 1 + xLen, pub->key.eccPub.len, y, yLen) != EOK, CRYPT_SECUREC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetParaById(*pkeyPub, ECDH_VECTOR.curveId) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(*pkeyPub, pub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_FREE(x);
BSL_SAL_FREE(y);
return ret;
}
static bool CRYPT_CMVP_SelftestEcdhInternal(void *libCtx, const char *attrName)
{
bool ret = false;
CRYPT_EAL_PkeyCtx *bobPrvPkey = NULL;
CRYPT_EAL_PkeyCtx *bobPubPkey = NULL;
CRYPT_EAL_PkeyPub bobPub = { 0 };
CRYPT_EAL_PkeyPrv bobPrv = { 0 };
CRYPT_EAL_PkeyCtx *alicePrvPkey = NULL;
CRYPT_EAL_PkeyCtx *alicePubPkey = NULL;
CRYPT_EAL_PkeyPub alicePub = { 0 };
CRYPT_EAL_PkeyPrv alicePrv = { 0 };
uint8_t *shareKey = NULL;
uint32_t shareKeyLen;
uint8_t *expShareKey = NULL;
uint32_t expShareKeyLen;
expShareKey = CMVP_StringsToBins(ECDH_VECTOR.shareKey, &expShareKeyLen);
GOTO_ERR_IF_TRUE(expShareKey == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(GetPkey(libCtx, attrName, true, &bobPrvPkey, &bobPubPkey, &bobPub, &bobPrv) != true,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(GetPkey(libCtx, attrName, false, &alicePrvPkey, &alicePubPkey, &alicePub, &alicePrv) != true,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
shareKeyLen = CRYPT_EAL_PkeyGetKeyLen(bobPrvPkey);
shareKey = BSL_SAL_Malloc(shareKeyLen);
GOTO_ERR_IF_TRUE(shareKey == NULL, CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyComputeShareKey(bobPrvPkey, alicePubPkey, shareKey, &shareKeyLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(shareKeyLen != expShareKeyLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(expShareKey, shareKey, shareKeyLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
shareKeyLen = CRYPT_EAL_PkeyGetKeyLen(bobPrvPkey);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyComputeShareKey(alicePrvPkey, bobPubPkey, shareKey, &shareKeyLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(shareKeyLen != expShareKeyLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(expShareKey, shareKey, shareKeyLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(bobPub.key.eccPub.data);
BSL_SAL_Free(bobPrv.key.eccPrv.data);
CRYPT_EAL_PkeyFreeCtx(bobPrvPkey);
CRYPT_EAL_PkeyFreeCtx(bobPubPkey);
BSL_SAL_Free(alicePub.key.eccPub.data);
BSL_SAL_Free(alicePrv.key.eccPrv.data);
CRYPT_EAL_PkeyFreeCtx(alicePrvPkey);
CRYPT_EAL_PkeyFreeCtx(alicePubPkey);
BSL_SAL_Free(shareKey);
BSL_SAL_Free(expShareKey);
return ret;
}
bool CRYPT_CMVP_SelftestEcdh(void)
{
return CRYPT_CMVP_SelftestEcdhInternal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderEcdh(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestEcdhInternal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_ecdh.c | C | unknown | 6,935 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_bn.h"
#include "crypt_encode_internal.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_util_rand.h"
#include "securec.h"
#include "bsl_sal.h"
#define BITS_OF_BYTE 8
typedef struct {
const char *msg;
const char *d;
const char *qX;
const char *qY;
const char *k;
const char *signR;
const char *signS;
int32_t curveId;
CRYPT_MD_AlgId mdId;
} CMVP_EcdsaVector;
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/dss/186-4ecdsatestvectors.zip
static const CMVP_EcdsaVector ECDSA_VECTOR = {
.msg = "ff624d0ba02c7b6370c1622eec3fa2186ea681d1659e0a845448e777b75a8e77"
"a77bb26e5733179d58ef9bc8a4e8b6971aef2539f77ab0963a3415bbd6258339"
"bd1bf55de65db520c63f5b8eab3d55debd05e9494212170f5d65b3286b8b6687"
"05b1e2b2b5568610617abb51d2dd0cb450ef59df4b907da90cfa7b268de8c4c2",
.d = "708309a7449e156b0db70e5b52e606c7e094ed676ce8953bf6c14757c826f590",
.qX = "29578c7ab6ce0d11493c95d5ea05d299d536801ca9cbd50e9924e43b733b83ab",
.qY = "08c8049879c6278b2273348474158515accaa38344106ef96803c5a05adc4800",
.k = "58f741771620bdc428e91a32d86d230873e9140336fcfb1e122892ee1d501bdc",
.signR = "4a19274429e40522234b8785dc25fc524f179dcc95ff09b3c9770fc71f54ca0d",
.signS = "58982b79a65b7320f5b92d13bdaecdd1259e760f0f718ba933fd098f6f75d4b7",
.curveId = CRYPT_ECC_NISTP256,
.mdId = CRYPT_MD_SHA224
};
static bool GetPkey(void *libCtx, const char *attrName, CRYPT_EAL_PkeyCtx **pkeyPrv, CRYPT_EAL_PkeyCtx **pkeyPub,
CRYPT_EAL_PkeyPub *pub, CRYPT_EAL_PkeyPrv *prv)
{
bool ret = false;
uint8_t *x = NULL;
uint8_t *y = NULL;
uint32_t xLen, yLen;
*pkeyPrv = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_ECDSA, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPrv == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
*pkeyPub = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_ECDSA, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPub == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
prv->id = CRYPT_PKEY_ECDSA;
prv->key.eccPrv.data = CMVP_StringsToBins(ECDSA_VECTOR.d, &(prv->key.eccPrv.len));
GOTO_ERR_IF_TRUE(prv->key.eccPrv.data == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetParaById(*pkeyPrv, ECDSA_VECTOR.curveId) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(*pkeyPrv, prv) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
pub->id = CRYPT_PKEY_ECDSA;
x = CMVP_StringsToBins(ECDSA_VECTOR.qX, &xLen);
GOTO_ERR_IF_TRUE(x == NULL, CRYPT_CMVP_COMMON_ERR);
y = CMVP_StringsToBins(ECDSA_VECTOR.qY, &yLen);
GOTO_ERR_IF_TRUE(y == NULL, CRYPT_CMVP_COMMON_ERR);
pub->key.eccPub.len = xLen + yLen + 1;
pub->key.eccPub.data = BSL_SAL_Malloc(pub->key.eccPub.len);
GOTO_ERR_IF_TRUE(pub->key.eccPub.data == NULL, CRYPT_MEM_ALLOC_FAIL);
pub->key.eccPub.data[0] = 0x04; // CRYPT_POINT_UNCOMPRESSED标记头
GOTO_ERR_IF_TRUE(memcpy_s(pub->key.eccPub.data + 1, pub->key.eccPub.len, x, xLen) != EOK, CRYPT_SECUREC_FAIL);
GOTO_ERR_IF_TRUE(
memcpy_s(pub->key.eccPub.data + 1 + xLen, pub->key.eccPub.len, y, yLen) != EOK, CRYPT_SECUREC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetParaById(*pkeyPub, ECDSA_VECTOR.curveId) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(*pkeyPub, pub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(x);
BSL_SAL_Free(y);
return ret;
}
static int32_t TestVectorRandom(uint8_t *r, uint32_t rLen)
{
uint8_t *rand = NULL;
uint32_t randLen;
rand = CMVP_StringsToBins(ECDSA_VECTOR.k, &randLen);
if (rand == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
if (randLen < rLen) {
BSL_SAL_Free(rand);
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
for (uint32_t i = 0; i < randLen; i++) {
r[i] = rand[i];
}
BSL_SAL_Free(rand);
return 0;
}
static int SignEncode(const char *signR, const char *signS, uint8_t *vectorSign, uint32_t *vectorSignLen)
{
int ret = CRYPT_CMVP_ERR_ALGO_SELFTEST;
BN_BigNum *bnR = NULL;
BN_BigNum *bnS = NULL;
uint8_t *r = NULL;
uint8_t *s = NULL;
uint32_t rLen, sLen;
r = CMVP_StringsToBins(signR, &rLen);
GOTO_ERR_IF_TRUE(r == NULL, CRYPT_CMVP_COMMON_ERR);
s = CMVP_StringsToBins(signS, &sLen);
GOTO_ERR_IF_TRUE(s == NULL, CRYPT_CMVP_COMMON_ERR);
bnR = BN_Create(rLen * BITS_OF_BYTE);
bnS = BN_Create(sLen * BITS_OF_BYTE);
GOTO_ERR_IF_TRUE(BN_Bin2Bn(bnR, r, rLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(BN_Bin2Bn(bnS, s, sLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = CRYPT_EAL_EncodeSign(bnR, bnS, vectorSign, vectorSignLen);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = CRYPT_SUCCESS;
ERR:
BSL_SAL_Free(r);
BSL_SAL_Free(s);
BN_Destroy(bnR);
BN_Destroy(bnS);
return ret;
}
static bool CRYPT_CMVP_SelftestEcdsaInternal(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *sign = NULL;
uint8_t *signVec = NULL;
uint32_t signLen;
uint32_t signVecLen = 0;
uint8_t *msg = NULL;
uint32_t msgLen;
CRYPT_EAL_PkeyCtx *pkeyPrv = NULL;
CRYPT_EAL_PkeyCtx *pkeyPub = NULL;
CRYPT_EAL_PkeyPub pub = { 0 };
CRYPT_EAL_PkeyPrv prv = { 0 };
CRYPT_EAL_RandFunc func = CRYPT_RandRegistGet();
CRYPT_EAL_RandFuncEx funcEx = CRYPT_RandRegistExGet();
CRYPT_RandRegistEx(NULL);
msg = CMVP_StringsToBins(ECDSA_VECTOR.msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(GetPkey(libCtx, attrName, &pkeyPrv, &pkeyPub, &pub, &prv) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
signLen = CRYPT_EAL_PkeyGetSignLen(pkeyPrv);
sign = BSL_SAL_Malloc(signLen);
signVecLen = signLen;
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_MEM_ALLOC_FAIL);
signVec = BSL_SAL_Malloc(signLen);
GOTO_ERR_IF_TRUE(signVec == NULL, CRYPT_MEM_ALLOC_FAIL);
// regist rand function
CRYPT_RandRegist(TestVectorRandom);
// sign
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySign(pkeyPrv, ECDSA_VECTOR.mdId, msg, msgLen, sign, &signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
// compare the signature
GOTO_ERR_IF_TRUE(SignEncode(ECDSA_VECTOR.signR, ECDSA_VECTOR.signS, signVec, &signVecLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(signLen != signVecLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(signVec, sign, signLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
// verify
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyVerify(pkeyPub, ECDSA_VECTOR.mdId, msg, msgLen, sign, signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(pub.key.eccPub.data);
BSL_SAL_Free(prv.key.eccPrv.data);
BSL_SAL_Free(sign);
BSL_SAL_Free(signVec);
BSL_SAL_Free(msg);
CRYPT_EAL_PkeyFreeCtx(pkeyPrv);
CRYPT_EAL_PkeyFreeCtx(pkeyPub);
CRYPT_RandRegist(func);
CRYPT_RandRegistEx(funcEx);
return ret;
}
bool CRYPT_CMVP_SelftestEcdsa(void)
{
return CRYPT_CMVP_SelftestEcdsaInternal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderEcdsa(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestEcdsaInternal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_ecdsa.c | C | unknown | 8,267 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
const char *prv;
const char *pub;
const char *msg;
const char *sign;
CRYPT_MD_AlgId mdId;
} CMVP_ED25519_VECTOR;
// https://datatracker.ietf.org/doc/html/rfc8032.html#page-24
static const CMVP_ED25519_VECTOR ED25519_VECTOR = {
.prv = "4ccd089b28ff96da9db6c346ec114e0f5b8a319f35aba624da8cf6ed4fb8a6fb",
.pub = "3d4017c3e843895a92b70aa74d1b7ebc9c982ccf2ec4968cc0cd55f12af4660c",
.msg = "72",
.sign = "92a009a9f0d4cab8720e820b5f642540a2b27b5416503f8fb3762223ebdb69da085ac1e43e15996e"
"458f3613d0f11d8c387b2eaeb4302aeeb00d291612bb0c00",
.mdId = CRYPT_MD_SHA512
};
static void FreeData(uint8_t *prv, uint8_t *pub, uint8_t *msg, uint8_t *expSign, uint8_t *sign)
{
BSL_SAL_Free(prv);
BSL_SAL_Free(pub);
BSL_SAL_Free(msg);
BSL_SAL_Free(expSign);
BSL_SAL_Free(sign);
}
static bool CRYPT_CMVP_SelftestEd25519Internal(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *prv = NULL;
uint8_t *pub = NULL;
uint8_t *msg = NULL;
uint8_t *expSign = NULL;
uint8_t *sign = NULL;
uint32_t prvLen, pubLen, msgLen, expSignLen, signLen;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
CRYPT_EAL_PkeyCtx *pubCtx = NULL;
CRYPT_EAL_PkeyPrv prvKey = {0};
CRYPT_EAL_PkeyPub pubKey;
prv = CMVP_StringsToBins(ED25519_VECTOR.prv, &prvLen);
GOTO_ERR_IF_TRUE(prv == NULL, CRYPT_CMVP_COMMON_ERR);
pub = CMVP_StringsToBins(ED25519_VECTOR.pub, &pubLen);
GOTO_ERR_IF_TRUE(pub == NULL, CRYPT_CMVP_COMMON_ERR);
msg = CMVP_StringsToBins(ED25519_VECTOR.msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
expSign = CMVP_StringsToBins(ED25519_VECTOR.sign, &expSignLen);
GOTO_ERR_IF_TRUE(expSign == NULL, CRYPT_CMVP_COMMON_ERR);
signLen = expSignLen;
sign = BSL_SAL_Malloc(signLen);
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_MEM_ALLOC_FAIL);
prvKey.id = CRYPT_PKEY_ED25519;
prvKey.key.curve25519Prv.data = prv;
prvKey.key.curve25519Prv.len = prvLen;
prvCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_ED25519, 0, attrName);
GOTO_ERR_IF_TRUE(prvCtx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(prvCtx, &prvKey) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySign(prvCtx, ED25519_VECTOR.mdId, msg, msgLen, sign, &signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(signLen != expSignLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(expSign, sign, signLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
pubKey.id = CRYPT_PKEY_ED25519;
pubKey.key.curve25519Pub.data = pub;
pubKey.key.curve25519Pub.len = pubLen;
pubCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_ED25519, 0, attrName);
GOTO_ERR_IF_TRUE(pubCtx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(pubCtx, &pubKey) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyVerify(pubCtx, ED25519_VECTOR.mdId, msg, msgLen, sign, signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
FreeData(prv, pub, msg, expSign, sign);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
CRYPT_EAL_PkeyFreeCtx(pubCtx);
return ret;
}
bool CRYPT_CMVP_SelftestEd25519(void)
{
return CRYPT_CMVP_SelftestEd25519Internal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderEd25519(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestEd25519Internal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_ed25519.c | C | unknown | 4,464 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "crypt_params_key.h"
#include "crypt_errno.h"
#include "crypt_eal_kdf.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
const char *ikm;
const char *salt;
const char *info;
const char *okm;
CRYPT_MAC_AlgId id;
} CMVP_HKDF_VECTOR;
// https://datatracker.ietf.org/doc/html/rfc5869.html#appendix-A
static const CMVP_HKDF_VECTOR HKDF_VECTOR = {
.ikm = "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
.salt = "000102030405060708090a0b0c",
.info = "f0f1f2f3f4f5f6f7f8f9",
.okm = "3cb25f25faacd57a90434f64d0362f2a2d2d0a90cf1a5a4c5db02d56ecc4c5bf34007208d5b887185865",
.id = CRYPT_MAC_HMAC_SHA256
};
static bool CRYPT_CMVP_SelftestHkdfInternal(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *key = NULL;
uint8_t *salt = NULL;
uint8_t *info = NULL;
uint8_t *expOut = NULL;
uint8_t *out = NULL;
uint32_t keyLen, saltLen, infoLen, expOutLen;
CRYPT_EAL_KdfCTX *ctx = NULL;
CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_FULL;
CRYPT_MAC_AlgId id = CRYPT_MAC_HMAC_SHA256;
key = CMVP_StringsToBins(HKDF_VECTOR.ikm, &keyLen);
GOTO_ERR_IF_TRUE(key == NULL, CRYPT_CMVP_COMMON_ERR);
salt = CMVP_StringsToBins(HKDF_VECTOR.salt, &saltLen);
GOTO_ERR_IF_TRUE(salt == NULL, CRYPT_CMVP_COMMON_ERR);
info = CMVP_StringsToBins(HKDF_VECTOR.info, &infoLen);
GOTO_ERR_IF_TRUE(info == NULL, CRYPT_CMVP_COMMON_ERR);
expOut = CMVP_StringsToBins(HKDF_VECTOR.okm, &expOutLen);
GOTO_ERR_IF_TRUE(expOut == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(expOut == NULL, CRYPT_CMVP_COMMON_ERR);
out = BSL_SAL_Malloc(expOutLen);
GOTO_ERR_IF_TRUE(out == NULL, CRYPT_MEM_ALLOC_FAIL);
ctx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_HKDF, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
BSL_Param param[6] = {
{CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &id, sizeof(id), 0},
{CRYPT_PARAM_KDF_MODE, BSL_PARAM_TYPE_UINT32, &mode, sizeof(mode), 0},
{CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS, key, keyLen, 0},
{CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS, salt, saltLen, 0},
{CRYPT_PARAM_KDF_INFO, BSL_PARAM_TYPE_OCTETS, info, infoLen, 0},
BSL_PARAM_END
};
GOTO_ERR_IF_TRUE(CRYPT_EAL_KdfSetParam(ctx, param) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_KdfDerive(ctx, out, expOutLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(out, expOut, expOutLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(key);
BSL_SAL_Free(salt);
BSL_SAL_Free(info);
BSL_SAL_Free(expOut);
BSL_SAL_Free(out);
CRYPT_EAL_KdfFreeCtx(ctx);
return ret;
}
bool CRYPT_CMVP_SelftestHkdf(void)
{
return CRYPT_CMVP_SelftestHkdfInternal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderHkdf(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestHkdfInternal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_hkdf.c | C | unknown | 3,825 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_kdf.h"
#include "crypt_params_key.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
const char *key;
const char *label;
const char *seed;
const char *dk;
CRYPT_MAC_AlgId id;
} CMVP_KDFTLS12_VECTOR;
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/components/800-135testvectors/tls.zip
static const CMVP_KDFTLS12_VECTOR KDF_TLS12_VECTOR = {
.key = "202c88c00f84a17a20027079604787461176455539e705be730890602c289a5001e34eeb3a043e5d52a65e66125188bf",
.label = "6b657920657870616e73696f6eae6c806f8ad4d80784549dff28a4b58fd837681a51d928c3e30ee5ff14f3986862e1fd91",
.seed = "f23f558a605f28478c58cf72637b89784d959df7e946d3f07bd1b616",
.dk = "d06139889fffac1e3a71865f504aa5d0d2a2e89506c6f2279b670c3e1b74f531016a25"
"30c51a3a0f7e1d6590d0f0566b2f387f8d11fd4f731cdd572d2eae927f6f2f81410b25"
"e6960be68985add6c38445ad9f8c64bf8068bf9a6679485d966f1ad6f68b43495b10a6"
"83755ea2b858d70ccac7ec8b053c6bd41ca299d4e51928",
.id = CRYPT_MAC_HMAC_SHA256
};
static bool CRYPT_CMVP_SelftestKdfTls12Internal(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *key = NULL;
uint8_t *label = NULL;
uint8_t *seed = NULL;
uint8_t *expDk = NULL;
uint8_t *dk = NULL;
uint32_t keyLen, labelLen, seedLen, expDkLen;
CRYPT_EAL_KdfCTX *ctx = NULL;
CRYPT_MAC_AlgId id = CRYPT_MAC_HMAC_SHA256;
key = CMVP_StringsToBins(KDF_TLS12_VECTOR.key, &keyLen);
GOTO_ERR_IF_TRUE(key == NULL, CRYPT_CMVP_COMMON_ERR);
label = CMVP_StringsToBins(KDF_TLS12_VECTOR.label, &labelLen);
GOTO_ERR_IF_TRUE(label == NULL, CRYPT_CMVP_COMMON_ERR);
seed = CMVP_StringsToBins(KDF_TLS12_VECTOR.seed, &seedLen);
GOTO_ERR_IF_TRUE(seed == NULL, CRYPT_CMVP_COMMON_ERR);
expDk = CMVP_StringsToBins(KDF_TLS12_VECTOR.dk, &expDkLen);
GOTO_ERR_IF_TRUE(expDk == NULL, CRYPT_CMVP_COMMON_ERR);
dk = BSL_SAL_Malloc(expDkLen);
GOTO_ERR_IF_TRUE(dk == NULL, CRYPT_MEM_ALLOC_FAIL);
ctx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_KDFTLS12, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
BSL_Param param[5] = {
{CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &id, sizeof(id), 0},
{CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS, key, keyLen, 0},
{CRYPT_PARAM_KDF_LABEL, BSL_PARAM_TYPE_OCTETS, label, labelLen, 0},
{CRYPT_PARAM_KDF_SEED, BSL_PARAM_TYPE_OCTETS, seed, seedLen, 0},
BSL_PARAM_END
};
GOTO_ERR_IF_TRUE(CRYPT_EAL_KdfSetParam(ctx, param) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_KdfDerive(ctx, dk, expDkLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(dk, expDk, expDkLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(key);
BSL_SAL_Free(label);
BSL_SAL_Free(seed);
BSL_SAL_Free(expDk);
BSL_SAL_Free(dk);
CRYPT_EAL_KdfFreeCtx(ctx);
return ret;
}
bool CRYPT_CMVP_SelftestKdfTls12(void)
{
return CRYPT_CMVP_SelftestKdfTls12Internal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderKdfTls12(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestKdfTls12Internal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_kdftls12.c | C | unknown | 4,134 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_mac.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
#include "crypt_local_types.h"
#define MAC_TYPE_HMAC_CMAC 1
#define MAC_TYPE_GMAC 2
#define MAC_TYPE_CBC_MAC 3
typedef struct {
uint32_t id;
const char *key;
const char *msg;
const char *mac;
const char *iv;
uint32_t type;
} CMVP_MAC_VECTOR;
static const CMVP_MAC_VECTOR MAC_VECTOR[] = {
// CRYPT_MAC_HMAC_MD5
// https://datatracker.ietf.org/doc/html/rfc2202
{
.id = CRYPT_MAC_HMAC_MD5,
.key = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
.msg = "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD",
.mac = "56be34521d144c88dbb8c733f0e8b3f6",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_HMAC_SHA1
// https://datatracker.ietf.org/doc/html/rfc2202
{
.id = CRYPT_MAC_HMAC_SHA1,
.key = "0102030405060708090a0b0c0d0e0f10111213141516171819",
.msg = "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
.mac = "4c9007f4026250c6bc8414f9bf50c86c2d7235da",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_HMAC_SHA224
// https://datatracker.ietf.org/doc/html/rfc4231.html#page-4
{
.id = CRYPT_MAC_HMAC_SHA224,
.key = "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
.msg = "4869205468657265",
.mac = "896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_HMAC_SHA256
// https://datatracker.ietf.org/doc/html/rfc4231.html#page-4
{
.id = CRYPT_MAC_HMAC_SHA256,
.key = "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
.msg = "4869205468657265",
.mac = "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_HMAC_SHA384
// https://datatracker.ietf.org/doc/html/rfc4231.html#page-4
{
.id = CRYPT_MAC_HMAC_SHA384,
.key = "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
.msg = "4869205468657265",
.mac = "afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_HMAC_SHA512
// https://datatracker.ietf.org/doc/html/rfc4231.html#page-4
{
.id = CRYPT_MAC_HMAC_SHA512,
.key = "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
.msg = "4869205468657265",
.mac = "87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833"
"b7d6b8a702038b274eaea3f4e4be9d914""eeb61f1702e696c203a126854",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_HMAC_SM3
{
.id = CRYPT_MAC_HMAC_SM3,
.key = "00112233445566778899aabbccddeeff",
.msg = "6162636465666768696A6B6C6D6E6F707172737475767778797A", // abcdefghijklmnopqrstuvwxyz
.mac = "a51ce58c52ae29edd66a53e6aaf0745bf4fedbde899973b2d817290e646df87e",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_CMAC_AES128
// https://csrc.nist.gov/Projects/cryptographic-algorithm-validation-program/cavp-testing-block-cipher-modes#CMAC
{
.id = CRYPT_MAC_CMAC_AES128,
.key = "5fcad38ae778394912f8f1b8413cf773",
.msg = "07185502bf6d275c84e3ac4f5f77c3d4",
.mac = "fd44fbc0dd9719e8b569ff10421df4",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_CMAC_AES192
// https://csrc.nist.gov/Projects/cryptographic-algorithm-validation-program/cavp-testing-block-cipher-modes#CMAC
{
.id = CRYPT_MAC_CMAC_AES192,
.key = "7fea563a866571822472dade8a0bec4b98202d47a3443129",
.msg = "a206a1eb70a9d24bb5e72f314e7d91de074f59055653bdd24aab5f2bbe112436",
.mac = "3bfe96f05e9cf96a98bd",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_CMAC_AES256
// https://csrc.nist.gov/Projects/cryptographic-algorithm-validation-program/cavp-testing-block-cipher-modes#CMAC
{
.id = CRYPT_MAC_CMAC_AES256,
.key = "7bef8d35616108922aab78936967204980b8a4945b31602f5ef2feec9b144841",
.msg = "40affd355416200191ba64edec8d7d27ead235a7b2e01a12662273deb36379b8a748c422c31e046152d6f196f94e852b",
.mac = "b2d078071e318ec88de9",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_CMAC_SM4
// GB/T 15852.1-2020 B.6
{
.id = CRYPT_MAC_CMAC_SM4,
.key = "0123456789ABCDEFFEDCBA9876543210",
.msg = "54686973206973207468652074657374206d65737361676520666f72206d6163", // "This is the test message for mac"
.mac = "692c437100f3b5ee2b8abcef373d990c",
.iv = NULL,
.type = MAC_TYPE_HMAC_CMAC
},
// CRYPT_MAC_GMAC_AES128
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/mac/gcmtestvectors.zip
{
.id = CRYPT_MAC_GMAC_AES128,
.key = "bea48ae4980d27f357611014d4486625",
.msg = "8a50b0b8c7654bced884f7f3afda2ead",
.mac = "8e0f6d8bf05ffebe6f500eb1",
.iv = "32bddb5c3aa998a08556454c",
.type = MAC_TYPE_GMAC
},
// CRYPT_MAC_GMAC_AES192
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/mac/gcmtestvectors.zip
{
.id = CRYPT_MAC_GMAC_AES192,
.key = "41c5da8667ef725220ffe39ae0ac590ac9fca729ab60ada0",
.msg = "8b5c124bef6e2f0fe4d8c95cd5fa4cf1",
.mac = "204bdb1bd62154bf08922aaa54eed705",
.iv = "05ad13a5e2c2ab667e1a6fbc",
.type = MAC_TYPE_GMAC
},
// CRYPT_MAC_GMAC_AES256
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/mac/gcmtestvectors.zip
{
.id = CRYPT_MAC_GMAC_AES256,
.key = "78dc4e0aaf52d935c3c01eea57428f00ca1fd475f5da86a49c8dd73d68c8e223",
.msg = "b96baa8c1c75a671bfb2d08d06be5f36",
.mac = "3e5d486aa2e30b22e040b85723a06e76",
.iv = "d79cf22d504cc793c3fb6c8a",
.type = MAC_TYPE_GMAC
},
// CRYPT_MAC_CBC_MAC_SM4
// GB/T 15852.1-2020 B.2
{
.id = CRYPT_MAC_CBC_MAC_SM4,
.key = "0123456789ABCDEFFEDCBA9876543210",
.msg = "54686973206973207468652074657374206d65737361676520666f72206d6163", // "This is the test message for mac"
.mac = "16e02904efb765b706459c9edabdb519",
.iv = NULL,
.type = MAC_TYPE_CBC_MAC
},
{
.id = CRYPT_MAC_MAX,
.key = NULL,
.msg = NULL,
.mac = NULL,
.iv = NULL,
.type = 0
}
};
static void FreeData(uint8_t *key, uint8_t *msg, uint8_t *mac, uint8_t *expectMac, uint8_t *iv)
{
BSL_SAL_Free(key);
BSL_SAL_Free(msg);
BSL_SAL_Free(mac);
BSL_SAL_Free(expectMac);
BSL_SAL_Free(iv);
}
static bool GetData(const CMVP_MAC_VECTOR *macVec, CRYPT_Data *key, CRYPT_Data *msg,
CRYPT_Data *expectMac, CRYPT_Data *iv)
{
key->data = CMVP_StringsToBins(macVec->key, &(key->len));
GOTO_ERR_IF_TRUE(key->data == NULL, CRYPT_CMVP_COMMON_ERR);
msg->data = CMVP_StringsToBins(macVec->msg, &(msg->len));
GOTO_ERR_IF_TRUE(msg->data == NULL, CRYPT_CMVP_COMMON_ERR);
expectMac->data = CMVP_StringsToBins(macVec->mac, &(expectMac->len));
GOTO_ERR_IF_TRUE(expectMac->data == NULL, CRYPT_CMVP_COMMON_ERR);
if (macVec->iv != NULL) {
iv->data = CMVP_StringsToBins(macVec->iv, &(iv->len));
GOTO_ERR_IF_TRUE(iv->data == NULL, CRYPT_CMVP_COMMON_ERR);
}
return true;
ERR:
return false;
}
const CMVP_MAC_VECTOR *FindMacVectorById(CRYPT_MAC_AlgId id)
{
uint32_t num = sizeof(MAC_VECTOR) / sizeof(MAC_VECTOR[0]);
const CMVP_MAC_VECTOR *macVec = NULL;
for (uint32_t i = 0; i < num; i++) {
if (MAC_VECTOR[i].id == id) {
macVec = &MAC_VECTOR[i];
return macVec;
}
}
return NULL;
}
static bool CRYPT_CMVP_SelftestMacInternal(void *libCtx, const char *attrName, CRYPT_MAC_AlgId id)
{
bool ret = false;
CRYPT_EAL_MacCtx *ctx = NULL;
CRYPT_Data key = { NULL, 0 };
CRYPT_Data msg = { NULL, 0 };
CRYPT_Data iv = { NULL, 0 };
uint8_t *mac = NULL;
uint32_t macLen = 0;
CRYPT_Data expectMac = { NULL, 0 };
const CMVP_MAC_VECTOR *macVec = FindMacVectorById(id);
// HMAC-MD5 is a non-approved algorithm and does not provide self-test.
if (macVec == NULL || macVec->msg == NULL || macVec->id == CRYPT_MAC_HMAC_MD5) {
return false;
}
GOTO_ERR_IF_TRUE(!GetData(macVec, &key, &msg, &expectMac, &iv), CRYPT_CMVP_ERR_ALGO_SELFTEST);
ctx = CRYPT_EAL_ProviderMacNewCtx(libCtx, id, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (macVec->type == MAC_TYPE_GMAC) {
macLen = expectMac.len;
} else {
macLen = CRYPT_EAL_GetMacLen(ctx);
}
mac = BSL_SAL_Malloc(macLen);
GOTO_ERR_IF_TRUE(mac == NULL, CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacInit(ctx, key.data, key.len) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (macVec->type == MAC_TYPE_GMAC) {
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_IV, iv.data, iv.len) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &macLen, sizeof(uint32_t)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
if (macVec->type == MAC_TYPE_CBC_MAC) {
CRYPT_PaddingType padType = CRYPT_PADDING_ZEROS;
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacCtrl(ctx, CRYPT_CTRL_SET_CBC_MAC_PADDING, &padType, sizeof(CRYPT_PaddingType)) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacUpdate(ctx, msg.data, msg.len) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MacFinal(ctx, mac, &macLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(mac, expectMac.data, expectMac.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
FreeData(key.data, msg.data, mac, expectMac.data, iv.data);
CRYPT_EAL_MacDeinit(ctx);
CRYPT_EAL_MacFreeCtx(ctx);
return ret;
}
bool CRYPT_CMVP_SelftestMac(CRYPT_MAC_AlgId id)
{
return CRYPT_CMVP_SelftestMacInternal(NULL, NULL, id);
}
bool CRYPT_CMVP_SelftestProviderMac(void *libCtx, const char *attrName, CRYPT_MAC_AlgId id)
{
return CRYPT_CMVP_SelftestMacInternal(libCtx, attrName, id);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_mac.c | C | unknown | 11,545 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_md.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
uint32_t id;
const char *msg;
const char *md;
} CMVP_HASH_VECTOR;
static const CMVP_HASH_VECTOR HASH_VECTOR[] = {
// CRYPT_MD_MD5
{
.id = CRYPT_MD_MD5,
.msg = NULL,
.md = NULL
},
// CRYPT_MD_SHA1
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA1,
.msg = "7e3d7b3eada98866",
.md = "24a2c34b976305277ce58c2f42d5092031572520"
},
// CRYPT_MD_SHA224
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA224,
.msg = "5f77b3664823c33e",
.md = "bdf21ff325f754157ccf417f4855360a72e8fd117d28c8fe7da3ea38"
},
// CRYPT_MD_SHA256
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA256,
.msg = "5738c929c4f4ccb6",
.md = "963bb88f27f512777aab6c8b1a02c70ec0ad651d428f870036e1917120fb48bf"
},
// CRYPT_MD_SHA384
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA384,
.msg = "de60275bdafce4b1",
.md = "a3d861d866c1362423eb21c6bec8e44b74ce993c55baa2b6640567560ebecdaeda07183dbbbd95e0"
"f522caee5ddbdaf0"
},
// CRYPT_MD_SHA512
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA512,
.msg = "6f8d58b7cab1888c",
.md = "a3941def2803c8dfc08f20c06ba7e9a332ae0c67e47ae57365c243ef40059b11be22c91da6a80c2c"
"ff0742a8f4bcd941bdee0b861ec872b215433ce8dcf3c031"
},
// CRYPT_MD_SHA3_224
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA3_224,
.msg = "d85e470a7c6988",
.md = "8a134c33c7abd673cd3d0c33956700760de980c5aee74c96e6ba08b2"
},
// CRYPT_MD_SHA3_256
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA3_256,
.msg = "8bca931c8a132d2f",
.md = "dbb8be5dec1d715bd117b24566dc3f24f2cc0c799795d0638d9537481ef1e03e"
},
// CRYPT_MD_SHA3_384
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA3_384,
.msg = "c44a2c58c84c393a",
.md = "60ad40f964d0edcf19281e415f7389968275ff613199a069c916a0ff7ef65503b740683162a622b913d43a46559e913c"
},
// CRYPT_MD_SHA3_512
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHA3_512,
.msg = "af53fa3ff8a3cfb2",
.md = "03c2ac02de1765497a0a6af466fb64758e3283ed83d02c0edb3904fd3cf296442e790018d4bf4ce55bc869"
"cebb4aa1a799afc9d987e776fef5dfe6628e24de97"
},
// CRYPT_MD_SHAKE128
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHAKE128,
.msg = "7bf2fef375bcaff3",
.md = "5ef5578b89c50532131b7843de7329a3"
},
// CRYPT_MD_SHAKE256
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing#shavs
{
.id = CRYPT_MD_SHAKE256,
.msg = "587cb398fe82ffda",
.md = "54f5dddb85f62dba7dc4727d502bdee959fb665bd482bd0ce31cbdd1a042e4b5"
},
// CRYPT_MD_SM3
{
.id = CRYPT_MD_SM3,
.msg = "616263",
.md = "66c7f0f462eeedd9d1f2d46bdc10e4e24167c4875cf2f7a2297da02b8f4ba8e0"
},
{
.id = CRYPT_MD_MAX,
.msg = NULL,
.md = NULL
}
};
static void FreeData(uint8_t *msg, uint8_t *md, uint8_t *expectMd)
{
BSL_SAL_Free(msg);
BSL_SAL_Free(md);
BSL_SAL_Free(expectMd);
}
const CMVP_HASH_VECTOR *FindVectorById(CRYPT_MD_AlgId id)
{
const CMVP_HASH_VECTOR *pHashVec = NULL;
uint32_t num = sizeof(HASH_VECTOR) / sizeof(HASH_VECTOR[0]);
for (uint32_t i = 0; i < num; i++) {
if (HASH_VECTOR[i].id == id) {
pHashVec = &HASH_VECTOR[i];
return pHashVec;
}
}
return NULL;
}
static bool CRYPT_CMVP_SelftestMdInternal(void *libCtx, const char *attrName, CRYPT_MD_AlgId id)
{
bool ret = false;
uint8_t *msg = NULL;
uint8_t *md = NULL;
uint8_t *expectMd = NULL;
uint32_t msgLen, mdLen, expectMdLen;
CRYPT_EAL_MdCTX *ctx = NULL;
const CMVP_HASH_VECTOR *hashVec = FindVectorById(id);
if (hashVec == NULL || hashVec->msg == NULL) {
return false;
}
msg = CMVP_StringsToBins(hashVec->msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
expectMd = CMVP_StringsToBins(hashVec->md, &expectMdLen);
GOTO_ERR_IF_TRUE(expectMd == NULL, CRYPT_CMVP_COMMON_ERR);
ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, id, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (id == CRYPT_MD_SHAKE128 || id == CRYPT_MD_SHAKE256) {
mdLen = expectMdLen;
} else {
mdLen = CRYPT_EAL_MdGetDigestSize(id);
}
md = BSL_SAL_Malloc(mdLen);
GOTO_ERR_IF_TRUE(md == NULL, CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MdInit(ctx) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MdUpdate(ctx, msg, msgLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_MdFinal(ctx, md, &mdLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(mdLen != expectMdLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(expectMd, md, mdLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
FreeData(msg, md, expectMd);
CRYPT_EAL_MdFreeCtx(ctx);
return ret;
}
bool CRYPT_CMVP_SelftestMd(CRYPT_MD_AlgId id)
{
return CRYPT_CMVP_SelftestMdInternal(NULL, NULL, id);
}
bool CRYPT_CMVP_SelftestProviderMd(void *libCtx, const char *attrName, CRYPT_MD_AlgId id)
{
return CRYPT_CMVP_SelftestMdInternal(libCtx, attrName, id);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_md.c | C | unknown | 7,164 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_util_rand.h"
#include "crypt_algid.h"
#include "securec.h"
#include "bsl_sal.h"
#define BITS_OF_BYTE 8
typedef struct {
const char *rnd;
const char *sk;
const char *pk;
const char *msg;
const char *sig;
int32_t algId;
int32_t type;
} CMVP_MldsaVector;
static const CMVP_MldsaVector MLDSA_VECTOR[] = {
{
// https://github.com/usnistgov/ACVP-Server/tree/master/gen-val/json-files/ML-DSA-sigGen-FIPS204
.rnd = "1D073BE3C59909102F6C26537E61E56CDB37FE1167E092DC3B73067E1B43B2A2",
.sk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
.pk = "C5459B7F833D8862B24945270793A9FA036D1C1CFB9AF2048FD6A53A5194ADB1B691D76050141493236DF39767EC9E2CDBAAF50613C38541E39F77E1415FF9BA5AD22EEDCFA2C69514ACC1FB9C8A3BD2D55E20E7624256E06A589D1C38EA2641723E9FA8A45A546050A266073F6977B5801DF8C4CF2DCD6965BD032C5D07269AD534CDD25495E574800E36733EAB8CB473163608097C271F8A75E9C4CBCE5170EA05CF4FD41288C4A57A6FB6685CC9B05FAEE90E674053270A8D700EE4313705DF5C14DA0A8D05CFD3807F3137C2F272D2A2DC18E7EC8A8E155E52A3974F413ACA3C3914C552CBD4CC36CD3F71FE8DEE522CD65FE4BFF2B51CE01DBAE4890D8B298995D159F60289277F77E9A8EA9DC1793E92730F4CA3514A9E2D0094123863F050393AF9932954A7AB58872EE333E522D87CDCF560C39DA2FF5750E0D85A6A81BCA8D42C6F3A08BA4A6D9B76385059030B1A131FDFF04F749D5AF87433FC05E6D9D580C832FF75F409BF9022EEAF8168A8B2ACCCA33BBC5FE1BDB44268EE77A39475439DADEFE6368CA1D1578EDCB5D3E5B862FAE157ED07584D1BDFADB71E31344FE51CF65A1D21D9037E876CC887FC30498CA6A54ADF7A4BCE24AE42C4C56AC29691A332108DBD00C4C368653B109D998C4B05BCDEB7C86E9CAEE0D1D55F2EE46ACAEA41AF1BFF43A479D9C928DEFDF99B009CE3B08AE4CA9CADAA407138B82F80766D9E648440D012404056B187DF2B19D5C263B0767C7A1FAB17D0E94F2FB342A9D3C98F6BA4D5EBE75264ADFDC4F167B9DA5D36FA3FD419007D0BC8CD1DBB7E3E897D9D03F6D2F674B3E4C7370ABCA10D91C7FCB13866866E254D991AAE86E917C78EFFADB02E88CD73F5CF47D54C18171828FDE585FBA2608B803D2623F466F3802A46201C67EACB811B139CAA240873D3E28CC7A9E71E3B3E3CCE1B98BD31E8DB83E72F7ECC2E4F4D93004DE855E6AD89E9A0C72279B67EF351E944CBA0BACC6FE31778209B13D9ED4D2AACFD054BB50BD8E379CF86678399991B31B3C179AADAC600DEA359787CB0A16F5EE911E5653E8E0CCF75FFEC9B1240928E1AD95F9630639AA20A529D27A5ACCCDA87FB2ECE63D42D50FBE70C69140CF3E6623E185EAEB219DEB1B6F0BBDC45587B46F7908B07E363A8EFDB4C0FE7881628A7F885054E43A1854DBFFD574A92C7318F1467441F554644BEC8F2C4F090678C0CF79B7CAC3800BAD6AC459FD8A87C2E410762DB26EC6C202CA996F3DF1B718B8E2C3DCDF90F61F9B97C9998B0E13B84D15D6C2ECA3BBBDF47E0CE53971A952B66915EA0FFA1D47B22F826FF51E1AD6E47C8FFAC640A8BCFD8B1E8E81A1D3AD4275552CDFE495464E32182E6FC707F41846325F6B53DCB2EAC2A5B3E5B84D6449681E9220642382FDE5F1479953E0C4DBB52B84258EB5E5847DFC527799BE27052BC19F3D769B48F8CDA7A3BB5414FC1232B66C8585F6AA2DD15978F1D0CDA59D03E13D8DBA6EBE1BD7E05D7AB0E429A156425E99DD8CC548C1B855810D3CBE0F599DC2FDFCF50C19FEBBCD6C2CD3BB98315C3016FAECC27FF0C7FE41F369511EC69BAAAFB1306B962A10A1A4BEDE822C86912A9453DAA30C7C1BD05038BE97E382651CB67C33B76CCFD33E1DBC3AE5149C485DFE2115779183DE801FEA99ECBBC069720D10E48C7437D9152030D48193898BAB2CCBCD363ED68FE5C74DA50D301CE7E4327BD387982C6A9C295F9EBD7F5764F009400F56BEDB8FAC01B3E4A33EB85AEA353906BB6B2CBC3EEA650EE428F40B969A193F99E7F2A40F71347066D16D29F33D364F8499F8EA96A1BA68E6CDB30F7909E889E4DB804A201B516EBB2",
.msg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
.sig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
.algId = CRYPT_PKEY_ML_DSA,
.type = CRYPT_MLDSA_TYPE_MLDSA_44,
}
};
static const char *MLDSA_SEED_VECTOR = NULL;
static int32_t GetPkey(void *libCtx, const char *attrName, const CMVP_MldsaVector *vector, CRYPT_EAL_PkeyCtx **pkeyPrv,
CRYPT_EAL_PkeyCtx **pkeyPub)
{
int32_t ret = CRYPT_CMVP_ERR_ALGO_SELFTEST;
CRYPT_EAL_PkeyPrv prvKey = { 0 };
CRYPT_EAL_PkeyPub pubKey = { 0 };
*pkeyPrv = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, vector->algId, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPrv == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
*pkeyPub = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, vector->algId, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPub == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = CRYPT_EAL_PkeySetParaById(*pkeyPrv, vector->type);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
ret = CRYPT_EAL_PkeySetParaById(*pkeyPub, vector->type);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
int32_t val = 0;
ret = CRYPT_EAL_PkeyCtrl(*pkeyPrv, CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG, &val, sizeof(val));
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
ret = CRYPT_EAL_PkeyCtrl(*pkeyPub, CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG, &val, sizeof(val));
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
prvKey.id = vector->algId;
prvKey.key.mldsaPrv.data = CMVP_StringsToBins(vector->sk, &(prvKey.key.mldsaPrv.len));
ret = CRYPT_EAL_PkeySetPrv(*pkeyPrv, &prvKey);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
pubKey.id = vector->algId;
pubKey.key.mldsaPub.data = CMVP_StringsToBins(vector->pk, &(pubKey.key.mldsaPub.len));
ret = CRYPT_EAL_PkeySetPub(*pkeyPub, &pubKey);
ERR:
BSL_SAL_Free(prvKey.key.mldsaPrv.data);
BSL_SAL_Free(pubKey.key.mldsaPub.data);
return ret;
}
static int32_t TestVectorRandom(uint8_t *r, uint32_t rLen)
{
uint8_t *rand = NULL;
uint32_t randLen;
rand = CMVP_StringsToBins(MLDSA_SEED_VECTOR, &randLen);
if (rand == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
if (randLen < rLen) {
BSL_SAL_Free(rand);
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
for (uint32_t i = 0; i < randLen; i++) {
r[i] = rand[i];
}
BSL_SAL_Free(rand);
return 0;
}
static bool TestMldsaSignVerify(void *libCtx, const char *attrName, const CMVP_MldsaVector *vector)
{
bool ret = false;
uint8_t *sign = NULL;
uint8_t *signVec = NULL;
uint32_t signLen;
uint32_t signVecLen = 0;
uint8_t *msg = NULL;
uint32_t msgLen;
CRYPT_EAL_PkeyCtx *pkeyPrv = NULL;
CRYPT_EAL_PkeyCtx *pkeyPub = NULL;
CRYPT_EAL_RandFunc func = CRYPT_RandRegistGet();
CRYPT_EAL_RandFuncEx funcEx = CRYPT_RandRegistExGet();
CRYPT_RandRegistEx(NULL);
GOTO_ERR_IF_TRUE(
GetPkey(libCtx, attrName, vector, &pkeyPrv, &pkeyPub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
signLen = CRYPT_EAL_PkeyGetSignLen(pkeyPrv);
sign = BSL_SAL_Malloc(signLen);
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_MEM_ALLOC_FAIL);
msg = CMVP_StringsToBins(vector->msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
signVec = CMVP_StringsToBins(vector->sig, &signVecLen);
GOTO_ERR_IF_TRUE(signVec == NULL, CRYPT_CMVP_COMMON_ERR);
// regist rand function
MLDSA_SEED_VECTOR = vector->rnd;
CRYPT_RandRegist(TestVectorRandom);
// sign
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySign(pkeyPrv, CRYPT_MD_MAX, msg, msgLen, sign, &signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
// compare the signature
GOTO_ERR_IF_TRUE(signLen != signVecLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(signVec, sign, signLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
// verify
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyVerify(pkeyPub, CRYPT_MD_MAX, msg, msgLen, sign, signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(sign);
BSL_SAL_Free(signVec);
BSL_SAL_Free(msg);
CRYPT_EAL_PkeyFreeCtx(pkeyPrv);
CRYPT_EAL_PkeyFreeCtx(pkeyPub);
CRYPT_RandRegist(func);
CRYPT_RandRegistEx(funcEx);
return ret;
}
bool CRYPT_CMVP_SelftestMldsaSignVerify(void)
{
bool ret = TestMldsaSignVerify(NULL, NULL, &MLDSA_VECTOR[0]);
return ret;
}
bool CRYPT_CMVP_SelftestProviderMldsaSignVerify(void *libCtx, const char *attrName)
{
return TestMldsaSignVerify(libCtx, attrName, &MLDSA_VECTOR[0]);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */ | 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_mldsa.c | C | unknown | 24,761 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "crypt_util_rand.h"
#include "securec.h"
#include "bsl_sal.h"
#define BITS_OF_BYTE 8
typedef struct {
const char *ek;
const char *dk;
const char *c;
const char *k;
const char *m;
int32_t algId;
int32_t type;
} CMVP_MlkemVector;
static const CMVP_MlkemVector MLKEM_VECTOR[] = {
{
// https://github.com/usnistgov/ACVP-Server/tree/master/gen-val/json-files/ML-KEM-encapDecap-FIPS203
.ek = "EDDBA9CB830474EC0111408243A97335494DDDFA8D5C6A344B0C9ED1061A7D4A840891C24E140BE6D7BDEE01571A1312D4000591F2224B850105878FD3966F537AC348D042B95785B8171F18647619072780C131BDAA462D34A039014012BBB2197A4328F89CC5B750CAD9495BE607D5017DFA105D87C830432795B42C5E89D8B536C087592829ED934822768A1824696A278952627CA2EA73CDA4A306F972B8521B6A7B28DD0AC44E6A8C46BA7291D48574F8356065AFBB073DF9B84B520673F6644D3959BAD576497E0BC846F560CE697C35493A995597F66315639A7B20B84105EAA48F3B4593A0BF12D64AD4CB043B6435D44A2F5E136F21621B88704DF8855C4F1689761A239DFA6874455D48251EB087865AC3825C275A1018B112F01E82D8698F684C8EE127D9D25FB92B180677A36930793DAB0306AAC8BC80A79885B0737C6B319600BB859966AB9F082490E31B669008CD055921CB2360667180611485E5D70E774401739B16F54601D4A600608119E4B3112AAC92D1C094E40318D4259044D16D3AD62B35170B54D16F0F850C593B2062CC3A769B4D28B6A776F981D4BC835612349292B748E30098D29C668A80F68718BF40B7E785CE41C094A7326F3E6992D99B80E64350C5395823B1315160582EC10B01A4337C52C355E98B857B2DF0006A0E8AB49F5BA23B8C7E329C20F91386852A8948751C0F301465D713E7857A7BD8B6076C059BE378F74BB257750F544A31874B79ABEA78F8647E77001506919AA467019E924B7BE53705A5C9411A8B513C8C51300849136E77919CF83CBA9EA1CD6004AA7178C8E7D062E5E13544E060B34984F61C2EB6B56580C45F67DA8982A97BD5BBA9D98462161A55357079C15A2A33992D4B66093DB03676D0C385DCC6DD3C18EC8138738AA0FD6058C9F721C5E3131D7828C9675048949D0CE32E92A3363EC0527F54C89B5140590822D9C96CB1BAA43A8CACCC085EA6FB602B871128AB2C8A2A1644623A1D7175CF4A23F4B497B7BB4D0B652EA4272D7A99A9A5F4C54EAA6482D0BFB4E46EE482B892895C78DCBAE4414543E0BF8AC4C82889BC6DDC385624AC7805CCC644BB430588AA19723AEE5999EF2AE2565C3BB3",
.dk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
.c = "387F23816CA3AAE900520559080374E6BFF44117D50D78EC4CB4A5C08A955DBBDFCBDE0803301BA3E40A9C33CAAE6DFA71EED311D9ECB84B497D3259B614DA30C71803288904D0E1B9EA8FB5750878602148E6FCE794B91E2778B07D87706E620B727162290CA7CE27DDEC5110770614175CE61A837CE46DA95D6AE7FBD9D4709636807EB67CC5992A643EABA2C253050C7B63CA6CA83617BCAF453AC3E24B9C3617038AA3A2FDC52A32EE7B2EC2B67E5F442BFB8D5429F079096FA7D5B9FBD81B096A75F2C9FAAD8E97DDC003EB88F55F482775BA7BD661BFCFC27D3A7C1071C5A7B020E80F6950BF315A040F4CF025A74B42DC008F4C084690F43E8502BFB740538BF3DF05336DDD6E33A3A4679A33C8A724125A8EC897A593741CA9C934CEEC2F20C82CCF439011C5066937377183C8CC96046985B92F6D014E0223EA542A8BA0A789478EB4B4F04AA98F7E6A4D4AC8852E8670B5A4097F7584FA136A159DAF5005D9FEF08868BFBFBE15D320AEAFFB3DE18C8F39A22A876D750AAD4F85546A88B0D0B498535B590B191894F43763BD13379BBD2CDEF4C98A571103E9409B2227315AB892990984FD6C9F375164959E3035B16C650CE71AFB62F7E3BFC624FACC973B104B44F6A2BCEEE1AACF0C3D8CE9ADDCEB26E3E786C116B70A3CF2C63524F472A2F15DBAB3FF8FDE34F015DD8DCFCBB17793A552E805AD5541ADFC6890B5E3A4DDBBC1CDB9B36D12DC49CA22CBB91F5BB599EF86DC4B5820B8E3D965839DFAA9392D29A878315BEA9A6885994C0D07843A4DC2FB87D0C8507CB17C549C3E60564D263221635F831C9F1F6539F07248E5BA8571541CF69151630161C0DBA57DA3A3C6296FEB02C19E2080F57C657CA74656B88B708450DA5DED44594B12614054D643FEB674E18FD3B863DE526EFB6D2426A58AE363658E8318578029DA3388D5A3C81E53E22F2802CBFD52760AF128EDAE7D1FC3379642FD8B9A791B289D7ECFC546158FBDCFBE1643B03B6874F3BA918849D93E5C0172E684C303D8D58CC5DE703A35FDB5796B81CD415B35DAEB60FCC043827401542FE35AD72375",
.k = "9A4E2BCC0E5E40528B4C2879D8BE4BF7AA266C16762480054B475814789EABCA",
.m = "381C547CE06B687A7A17C1A99D11A7A4C35B82685AF51CE452099C60136FD84A",
.algId = CRYPT_PKEY_ML_KEM,
.type = CRYPT_KEM_TYPE_MLKEM_512,
}
};
static const char *MLKEM_SEED_VECTOR = NULL;
static int32_t GetPkey(void *libCtx, const char *attrName, const CMVP_MlkemVector *vector, CRYPT_EAL_PkeyCtx **pkeyPrv,
CRYPT_EAL_PkeyCtx **pkeyPub)
{
int32_t ret = CRYPT_CMVP_ERR_ALGO_SELFTEST;
CRYPT_EAL_PkeyPrv prvKey = { 0 };
CRYPT_EAL_PkeyPub pubKey = { 0 };
*pkeyPrv = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, vector->algId, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPrv == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
*pkeyPub = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, vector->algId, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPub == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = CRYPT_EAL_PkeySetParaById(*pkeyPrv, vector->type);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
ret = CRYPT_EAL_PkeySetParaById(*pkeyPub, vector->type);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
prvKey.id = vector->algId;
prvKey.key.mldsaPrv.data = CMVP_StringsToBins(vector->dk, &(prvKey.key.kemDk.len));
ret = CRYPT_EAL_PkeySetPrv(*pkeyPrv, &prvKey);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
pubKey.id = vector->algId;
pubKey.key.mldsaPub.data = CMVP_StringsToBins(vector->ek, &(pubKey.key.kemEk.len));
ret = CRYPT_EAL_PkeySetPub(*pkeyPub, &pubKey);
ERR:
BSL_SAL_Free(prvKey.key.kemDk.data);
BSL_SAL_Free(pubKey.key.kemEk.data);
return ret;
}
static int32_t TestVectorRandom(uint8_t *r, uint32_t rLen)
{
uint8_t *rand = NULL;
uint32_t randLen;
rand = CMVP_StringsToBins(MLKEM_SEED_VECTOR, &randLen);
if (rand == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
if (randLen < rLen) {
BSL_SAL_Free(rand);
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
for (uint32_t i = 0; i < randLen; i++) {
r[i] = rand[i];
}
BSL_SAL_Free(rand);
return 0;
}
static bool TestMlkemEncapsDecaps(void *libCtx, const char *attrName, const CMVP_MlkemVector *vector)
{
bool ret = false;
uint8_t *cipher = NULL;
uint8_t *cipherVec = NULL;
uint32_t cipherLen = 0;
uint32_t cipherVecLen = 0;
CRYPT_EAL_PkeyCtx *pkeyPrv = NULL;
CRYPT_EAL_PkeyCtx *pkeyPub = NULL;
uint8_t sharedKey[32] = { 0 };
uint32_t sharedLen = sizeof(sharedKey);
uint8_t *sharedKeyVec = NULL;
uint32_t sharedKeyVecLen = 0;
CRYPT_EAL_RandFunc func = CRYPT_RandRegistGet();
CRYPT_EAL_RandFuncEx funcEx = CRYPT_RandRegistExGet();
CRYPT_RandRegistEx(NULL);
GOTO_ERR_IF_TRUE(
GetPkey(libCtx, attrName, vector, &pkeyPrv, &pkeyPub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(pkeyPrv, CRYPT_CTRL_GET_CIPHERTEXT_LEN, &cipherLen, sizeof(cipherLen)) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
cipher = BSL_SAL_Malloc(cipherLen);
GOTO_ERR_IF_TRUE(cipher == NULL, CRYPT_MEM_ALLOC_FAIL);
cipherVec = CMVP_StringsToBins(vector->c, &cipherVecLen);
GOTO_ERR_IF_TRUE(cipherVec == NULL, CRYPT_CMVP_COMMON_ERR);
sharedKeyVec = CMVP_StringsToBins(vector->k, &sharedKeyVecLen);
GOTO_ERR_IF_TRUE(sharedKeyVec == NULL, CRYPT_CMVP_COMMON_ERR);
// regist rand function
MLKEM_SEED_VECTOR = vector->m;
CRYPT_RandRegist(TestVectorRandom);
// encaps
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyEncaps(pkeyPub, cipher, &cipherLen, sharedKey, &sharedLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(cipherLen != cipherVecLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(cipher, cipherVec, cipherLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(sharedLen != sharedKeyVecLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(sharedKey, sharedKeyVec, sharedLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
// decaps
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyDecaps(pkeyPrv, cipherVec, cipherVecLen, sharedKey, &sharedLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(sharedLen != sharedKeyVecLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(sharedKey, sharedKeyVec, sharedLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(cipher);
BSL_SAL_Free(cipherVec);
BSL_SAL_Free(sharedKeyVec);
CRYPT_EAL_PkeyFreeCtx(pkeyPrv);
CRYPT_EAL_PkeyFreeCtx(pkeyPub);
CRYPT_RandRegist(func);
CRYPT_RandRegistEx(funcEx);
return ret;
}
bool CRYPT_CMVP_SelftestMlkemEncapsDecaps(void)
{
bool ret = TestMlkemEncapsDecaps(NULL, NULL, &MLKEM_VECTOR[0]);
return ret;
}
bool CRYPT_CMVP_SelftestProviderMlkemEncapsDecaps(void *libCtx, const char *attrName)
{
return TestMlkemEncapsDecaps(libCtx, attrName, &MLKEM_VECTOR[0]);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */ | 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_mlkem.c | C | unknown | 12,690 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_kdf.h"
#include "bsl_err_internal.h"
#include "crypt_params_key.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
const char *pw;
const char *salt;
uint32_t iter;
const char *key;
CRYPT_MAC_AlgId id;
} CMVP_PBKDF2_VECTOR;
// https://www.ietf.org/rfc/rfc6070.txt
static const CMVP_PBKDF2_VECTOR PBKDF2_VECTOR[] = {
{
.pw = "passwordPASSWORDpassword",
.salt = "saltSALTsaltSALTsaltSALTsaltSALTsalt",
.iter = 4096,
.key = "3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038",
.id = CRYPT_MAC_HMAC_SHA1
},
{
.pw = "passwordPASSWORDpassword",
.salt = "saltSALTsaltSALTsaltSALTsaltSALTsalt",
.iter = 1024,
.key = "1e0d8ab1b32bb96dff58ff89ab171e643a425fd87f26261b56f9d38c992f2593a713f9c1772f8bf2",
.id = CRYPT_MAC_HMAC_SM3
},
};
static const CMVP_PBKDF2_VECTOR *FindVectorById(CRYPT_MAC_AlgId id)
{
const CMVP_PBKDF2_VECTOR *pPbkdf2Vec = NULL;
uint32_t num = sizeof(PBKDF2_VECTOR) / sizeof(PBKDF2_VECTOR[0]);
for (uint32_t i = 0; i < num; i++) {
if (PBKDF2_VECTOR[i].id == id) {
pPbkdf2Vec = &PBKDF2_VECTOR[i];
return pPbkdf2Vec;
}
}
return NULL;
}
static bool CRYPT_CMVP_SelftestPbkdf2Internal(void *libCtx, const char *attrName, CRYPT_MAC_AlgId id)
{
(void)id;
bool ret = false;
const char *pw = NULL;
const char *salt = NULL;
uint8_t *expOut = NULL;
uint8_t *out = NULL;
uint32_t expOutLen, pwLen, saltLen, iter;
CRYPT_EAL_KdfCTX *ctx = NULL;
const CMVP_PBKDF2_VECTOR *pbkdf2Vec = FindVectorById(id);
if (pbkdf2Vec == NULL || pbkdf2Vec->pw == NULL) {
return false;
}
iter = pbkdf2Vec->iter;
pw = pbkdf2Vec->pw;
pwLen = (uint32_t)strlen(pbkdf2Vec->pw);
salt = pbkdf2Vec->salt;
saltLen = (uint32_t)strlen(pbkdf2Vec->salt);
expOut = CMVP_StringsToBins(pbkdf2Vec->key, &expOutLen);
GOTO_ERR_IF_TRUE(expOut == NULL, CRYPT_CMVP_COMMON_ERR);
out = BSL_SAL_Malloc(expOutLen);
GOTO_ERR_IF_TRUE(out == NULL, CRYPT_MEM_ALLOC_FAIL);
ctx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_PBKDF2, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
BSL_Param param[5] = {
{CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &id, sizeof(id), 0},
{CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS, (void *)(uintptr_t)pw, pwLen, 0},
{CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS, (void *)(uintptr_t)salt, saltLen, 0},
{CRYPT_PARAM_KDF_ITER, BSL_PARAM_TYPE_UINT32, &iter, sizeof(uint32_t), 0},
BSL_PARAM_END
};
GOTO_ERR_IF_TRUE(CRYPT_EAL_KdfSetParam(ctx, param) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_KdfDerive(ctx, out, expOutLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(out, expOut, expOutLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(expOut);
BSL_SAL_Free(out);
CRYPT_EAL_KdfFreeCtx(ctx);
return ret;
}
bool CRYPT_CMVP_SelftestPbkdf2(CRYPT_MAC_AlgId id)
{
return CRYPT_CMVP_SelftestPbkdf2Internal(NULL, NULL, id);
}
bool CRYPT_CMVP_SelftestProviderPbkdf2(void *libCtx, const char *attrName, CRYPT_MAC_AlgId id)
{
return CRYPT_CMVP_SelftestPbkdf2Internal(libCtx, attrName, id);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_pbkdf2.c | C | unknown | 4,260 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "crypt_utils.h"
#include "crypt_dsa.h"
#include "crypt_ecdsa.h"
#include "crypt_curve25519.h"
#include "crypt_rsa.h"
#include "crypt_sm2.h"
#include "crypt_mldsa.h"
#include "crypt_mlkem.h"
#include "crypt_eal_implprovider.h"
#include "crypt_slh_dsa.h"
#ifdef HITLS_CRYPTO_MLKEM
static bool CMVP_MlkemPct(void *ctx)
{
bool ret = false;
uint32_t cipherLen = 0;
uint8_t *ciphertext = NULL;
uint8_t sharedKey[32] = {0};
uint32_t sharedLen = sizeof(sharedKey);
uint8_t sharedKey2[32] = {0};
uint32_t sharedLen2 = sizeof(sharedKey2);
GOTO_ERR_IF_TRUE(CRYPT_ML_KEM_Ctrl(ctx, CRYPT_CTRL_GET_CIPHERTEXT_LEN, &cipherLen,
sizeof(cipherLen)) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ciphertext = BSL_SAL_Malloc(cipherLen);
GOTO_ERR_IF_TRUE(ciphertext == NULL, CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_ML_KEM_Encaps(ctx, ciphertext, &cipherLen, sharedKey, &sharedLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_ML_KEM_Decaps(ctx, ciphertext, cipherLen, sharedKey2, &sharedLen2) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(sharedLen != sharedLen2 || memcmp(sharedKey, sharedKey2, sharedLen) != 0,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(ciphertext);
return ret;
}
#endif
typedef struct {
int32_t id;
CRYPT_EAL_ImplPkeySign sign;
CRYPT_EAL_ImplPkeyVerify verify;
CRYPT_EAL_ImplPkeyMgmtCtrl ctrl;
} PkeyMethodMap;
static const PkeyMethodMap pkey_map[] = {
#ifdef HITLS_CRYPTO_DSA
{CRYPT_PKEY_DSA, (CRYPT_EAL_ImplPkeySign)CRYPT_DSA_Sign,
(CRYPT_EAL_ImplPkeyVerify)CRYPT_DSA_Verify, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_DSA_Ctrl},
#endif
#ifdef HITLS_CRYPTO_ED25519
{CRYPT_PKEY_ED25519, (CRYPT_EAL_ImplPkeySign)CRYPT_CURVE25519_Sign,
(CRYPT_EAL_ImplPkeyVerify)CRYPT_CURVE25519_Verify, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_CURVE25519_Ctrl},
#endif
#ifdef HITLS_CRYPTO_RSA
{CRYPT_PKEY_RSA, (CRYPT_EAL_ImplPkeySign)CRYPT_RSA_Sign,
(CRYPT_EAL_ImplPkeyVerify)CRYPT_RSA_Verify, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_RSA_Ctrl},
#endif
#ifdef HITLS_CRYPTO_ECDSA
{CRYPT_PKEY_ECDSA, (CRYPT_EAL_ImplPkeySign)CRYPT_ECDSA_Sign,
(CRYPT_EAL_ImplPkeyVerify)CRYPT_ECDSA_Verify, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_ECDSA_Ctrl},
#endif
#ifdef HITLS_CRYPTO_SM2
{CRYPT_PKEY_SM2, (CRYPT_EAL_ImplPkeySign)CRYPT_SM2_Sign,
(CRYPT_EAL_ImplPkeyVerify)CRYPT_SM2_Verify, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_SM2_Ctrl},
#endif
#ifdef HITLS_CRYPTO_SLH_DSA
{CRYPT_PKEY_SLH_DSA, (CRYPT_EAL_ImplPkeySign)CRYPT_SLH_DSA_Sign,
(CRYPT_EAL_ImplPkeyVerify)CRYPT_SLH_DSA_Verify, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_SLH_DSA_Ctrl},
#endif
#ifdef HITLS_CRYPTO_MLDSA
{CRYPT_PKEY_ML_DSA, (CRYPT_EAL_ImplPkeySign)CRYPT_ML_DSA_Sign,
(CRYPT_EAL_ImplPkeyVerify)CRYPT_ML_DSA_Verify, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_ML_DSA_Ctrl},
#endif
{CRYPT_PKEY_MAX, NULL, NULL, NULL}
};
static bool CMVP_SignVerifyPct(void *ctx, int32_t algId)
{
bool ret = false;
uint8_t *sign = NULL;
uint32_t signLen = 0;
const uint8_t msg[] = {0x01, 0x02, 0x03, 0x04};
uint32_t mdId = CRYPT_MD_SHA512;
const PkeyMethodMap *map = NULL;
for (uint32_t i = 0; i < sizeof(pkey_map) / sizeof(pkey_map[0]); i++) {
if (algId == pkey_map[i].id) {
map = &pkey_map[i];
break;
}
}
GOTO_ERR_IF_TRUE(map == NULL, CRYPT_EAL_ERR_ALGID);
GOTO_ERR_IF_TRUE(map->ctrl(ctx, CRYPT_CTRL_GET_SIGNLEN, &signLen, sizeof(signLen)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
sign = BSL_SAL_Malloc(signLen);
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_MEM_ALLOC_FAIL);
if (algId == CRYPT_PKEY_RSA) {
GOTO_ERR_IF_TRUE(map->ctrl(ctx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &mdId, sizeof(mdId)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
GOTO_ERR_IF_TRUE(map->sign(ctx, algId == CRYPT_PKEY_SM2 ? CRYPT_MD_SM3 : CRYPT_MD_SHA512, msg, sizeof(msg),
sign, &signLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(map->verify(ctx, algId == CRYPT_PKEY_SM2 ? CRYPT_MD_SM3 : CRYPT_MD_SHA512, msg, sizeof(msg),
sign, signLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(sign);
return ret;
}
bool CRYPT_CMVP_SelftestPkeyPct(void *ctx, int32_t algId)
{
if (algId == CRYPT_PKEY_DH || algId == CRYPT_PKEY_ECDH || algId == CRYPT_PKEY_X25519) {
return true;
}
#ifdef HITLS_CRYPTO_MLKEM
if (algId == CRYPT_PKEY_ML_KEM) {
return CMVP_MlkemPct(ctx);
}
#endif
return CMVP_SignVerifyPct(ctx, algId);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_pct.c | C | unknown | 5,574 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "bsl_err_internal.h"
#include "crypt_params_key.h"
#include "crypt_utils.h"
#include "crypt_eal_rand.h"
#include "crypt_util_rand.h"
#include "securec.h"
#include "bsl_sal.h"
#define PKCSV15_PAD 0
#define PSS_PAD 1
#define OAEP_PAD 2
#define MAX_CIPHER_TEXT_LEN 512
typedef struct {
const char *n;
const char *e;
const char *d;
const char *salt;
const char *msg;
const char *sign;
CRYPT_MD_AlgId mdId;
} CMVP_RSA_VECTOR;
// 与CRYPT_EAL_PkeyPadId顺序一致
static const CMVP_RSA_VECTOR RSA_VECTOR[] = {
// RSA-2048bits-SHA224 PKCS#1 Ver 1.5
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Digital-Signatures#rsa2vs
{
.n = "e0b14b99cd61cd3db9c2076668841324fa3174f33ce66ffd514394d34178d29a49493276b6777233"
"e7d46a3e68bc7ca7e899e901d54f6dee0749c3e48ddf68685867ee2ae66df88eb563f6db137a9f6b"
"175a112e0eda8368e88e45efe1ce14bc6016d52639627066af1872c72f60b9161c1d237eeb34b0f8"
"41b3f0896f9fe0e16b0f74352d101292cc464a7e7861bbeb86f6df6151cb265417c66c565ed8974b"
"d8fc984d5ddfd4eb91a3d5234ce1b5467f3ade375f802ec07293f1236efa3068bc91b158551c875c"
"5dc0a9d6fa321bf9421f08deac910e35c1c28549ee8eed8330cf70595ff70b94b49907e27698a9d9"
"11f7ac0706afcb1a4a39feb38b0a8049",
.e = "00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000010001",
.d = "1dbca92e4245c2d57bfba76210cc06029b502753b7c821a32b799fbd33c98b49db10226b1eac0143"
"c8574ef652833b96374d034ef84daa5559c693f3f028d49716b82e87a3f682f25424563bd9409dcf"
"9d08110500f73f74076f28e75e0199b1f29fa2f70b9a31190dec54e872a740e7a1b1e38c3d11bca8"
"267deb842cef4262237ac875725068f32563b478aca8d6a99f34cb8876b97145b2e8529ec8adea83"
"ead4ec63e3ff2d17a2ffefb05c902ca7a92168378c89f75c928fc4f0707e43487a4f47df70cae87e"
"24272c136d3e98cf59066d41a3d038857d073d8b4d2c27b8f0ea6bfa50d263091a4a18c63f446bc9"
"a61e8c4a688347b2435ec8e72eddaea7",
.salt = NULL,
.msg = "79bcffbfd6bcf638934b38e47a1b821dc97cafe1da757f820313989ebc01ca52ff5997abf5baf35d"
"ce9b48b8f0debdd755a8b81b2e71a1d8cd57ea4dc1b84cda43ff536dd1be1c3e18fe5ebc17d3a7c6"
"8233e81f6407341c0983c5a01bb3404a0b5739edb2f1fa41391c80d8361fc75317c248d5c461bfb8"
"803e317f101b2e0c",
.sign = "5cbc1d2c696e7c5c0a538db35a793959008564c43d9aa8ed20816b66ef77124eca7584631308d0fd"
"7383be62eaf799b5e67e8874cc9d88d507e1bd4fb9fd7517adebe5d583b075040ce3db2affcf77ee"
"0162be2e575413f455841cb6ea4a30595daee45e3042b0b9d8f9ee700df3f1898219777c21ef3695"
"af95628ae64260dd2cb7ee6270fb06f52ea1aea72e1a26a26f2e7cee560ae0cb8be323113c3f19c9"
"7cb5a3e61b998a68432aa2d1f8c8c00ac92b0f35344710ae1d6d79f379fbb3dba41b46b9c814eb3a"
"25ca64a3ff86af613d163f941a897676652e7c3f6769fd964b862dc58cc2e652d0a404e94853fb83"
"937c862c1df2df9fd297f058bf660d15",
.mdId = CRYPT_MD_SHA224
},
// RSA-2048bits-SHA224 PKCS#1 RSASSA-PSS
// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Digital-Signatures#rsa2vs
{
.n = "d95b71c9dfee453ba1b1a7de2c1f0b0a67579ee91d1d3ad97e481829b86edac750c48e12a8cdb026"
"c82f273dafc222009f0db3b08b2db10a69c4b2dddaaeceac1b0c862682eef294e579f55aab871bc0"
"a7eeabc923c9e80dddc22ec0a27002aee6a5ba66397f412bbaf5fb4eaf66a1a0f82eaf6827198caf"
"49b347258b1283e8cbb10da2837f6ecc3490c728fe927f44455a6f194f3776bf79151d9ad7e2daf7"
"70b37d12627cc0c5fb62484f46258d9ce2c11b26256d09cb412f8d8f8f1fe91bb94ac27de6d26a83"
"a8439e51b35dbee46b3b8ff991d667bb53eeee85ff1652c8981f141d47c8205791cef5b32d718ddc"
"082ed0dd542826416b2271064ef437a9",
.e = "00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000000000000000000000000000000000"
"00000000000000000000000000010001",
.d = "2f21b01be94dde7f5ec18a3817f3274ebb37f9c26cc8c0d1169c05794e7fe33ae31dabfd09d38845"
"f094a0fab458f14c9730be6d22d0e699ee7373a1bde0b7fa03e784536782eee1309d708197be355b"
"624ed3bb4ae2664a5372def67082bf6233ab6e2eea7ad8a3e5e79ef5e1fcec415e6fa923798f05bd"
"a0ca9a3bdedb45f4d781ef1a4f5075cd9bb399635da3e9a6880ed021a750bc9806af81fbffcd4ace"
"af804ec76808ae186715c772caa961a862991c67ca8bffef6b34087b44db5b59abce09317747fc75"
"252f1705260b13dd62ccbc745091f3c1b64f59031d340c7362a0e1066ab0554d466f209a3cf51bc6"
"4b3c70c3ce52f413d81b228fa31d9efd",
.salt = "6f2841166a64471d4f0b8ed0dbb7db32161da13b",
.msg = "e2b81456c355c3f80a363a85cbf245e85a5ff2435e5548d627b5362242aaca4e4a2fa4c900d2a931"
"9eb7fc7469df2a3586aaa4710e9b7362655c27a3c70210962391b1032dc37201af05951a1fc36baa"
"77e5c888419ab4e8f1546380781468ea16e7254a70b08630e229efc016257210d61846d11ed87432"
"76a5d4017e683813",
.sign = "cd1fe0acb89969ae139c178bfef1cc982993521b3a020ec847c89c0cc6c869d970f43f018d495b9e"
"991457e7501a344c33c376fd2efcf05ad6eb2bd0b3c0e7cc3c88a4124398ca16585490a0817a3614"
"9cc82cdc01b20e9026261215dd06f9db4e13613c6a569c2187a0e00bc63c281149433ac7f061bd21"
"8e79f8eca9dd9c93ebc3cc013bf27aa0bf286e124593e76d3c7012f97ae1d0c4bf5823cf17fe76d5"
"05a54cef174add58ae616f47de825049e9916bf2ab7de4d443745763b0c314cfae3a6e57ad475cc5"
"fae47cddcad7b526c2154a15f9ee8eab02f4c36f7a41d7a19b23c5996b627270ceb2c0dbed1a6b6d"
"d2ff94868e073cb7b1a1fa3429e487ae",
.mdId = CRYPT_MD_SHA224
},
};
typedef struct {
const char *n;
const char *e;
const char *d;
const char *seed;
const char *msg;
const char *cipher;
CRYPT_MD_AlgId mdId;
} CMVP_RSA_ENC_DEC_VECTOR;
// Test vectors sourced from the pyca/cryptography project.
static const CMVP_RSA_ENC_DEC_VECTOR RSA_ENC_DEC_VECTOR = {
.n = "ae45ed5601cec6b8cc05f803935c674ddbe0d75c4c09fd7951fc6b0caec313a8"
"df39970c518bffba5ed68f3f0d7f22a4029d413f1ae07e4ebe9e4177ce23e7f5"
"404b569e4ee1bdcf3c1fb03ef113802d4f855eb9b5134b5a7c8085adcae6fa2f"
"a1417ec3763be171b0c62b760ede23c12ad92b980884c641f5a8fac26bdad4a0"
"3381a22fe1b754885094c82506d4019a535a286afeb271bb9ba592de18dcf600"
"c2aeeae56e02f7cf79fc14cf3bdc7cd84febbbf950ca90304b2219a7aa063aef"
"a2c3c1980e560cd64afe779585b6107657b957857efde6010988ab7de417fc88"
"d8f384c4e6e72c3f943e0c31c0c4a5cc36f879d8a3ac9d7d59860eaada6b83bb",
.e = "010001",
.d = "056b04216fe5f354ac77250a4b6b0c8525a85c59b0bd80c56450a22d5f438e59"
"6a333aa875e291dd43f48cb88b9d5fc0d499f9fcd1c397f9afc070cd9e398c8d"
"19e61db7c7410a6b2675dfbf5d345b804d201add502d5ce2dfcb091ce9997bbe"
"be57306f383e4d588103f036f7e85d1934d152a323e4a8db451d6f4a5b1b0f10"
"2cc150e02feee2b88dea4ad4c1baccb24d84072d14e1d24a6771f7408ee30564"
"fb86d4393a34bcf0b788501d193303f13a2284b001f0f649eaf79328d4ac5c43"
"0ab4414920a9460ed1b7bc40ec653e876d09abc509ae45b525190116a0c26101"
"848298509c1c3bf3a483e7274054e15e97075036e989f60932807b5257751e79",
.msg = "8bba6bf82a6c0f86d5f1756e97956870b08953b06b4eb205bc1694ee",
.seed = "47e1ab7119fee56c95ee5eaad86f40d0aa63bd33",
.cipher = "53ea5dc08cd260fb3b858567287fa91552c30b2febfba213f0ae87702d068d19"
"bab07fe574523dfb42139d68c3c5afeee0bfe4cb7969cbf382b804d6e6139614"
"4e2d0e60741f8993c3014b58b9b1957a8babcd23af854f4c356fb1662aa72bfc"
"c7e586559dc4280d160c126785a723ebeebeff71f11594440aaef87d10793a87"
"74a239d4a04c87fe1467b9daf85208ec6c7255794a96cc29142f9a8bd418e3c1"
"fd67344b0cd0829df3b2bec60253196293c6b34d3f75d32f213dd45c6273d505"
"adf4cced1057cb758fc26aeefa441255ed4e64c199ee075e7f16646182fdb464"
"739b68ab5daff0e63e9552016824f054bf4d3c8c90a97bb6b6553284eb429fcc",
.mdId = CRYPT_MD_SHA1,
};
static bool GetPrvKey(const char *n, const char *d, CRYPT_EAL_PkeyPrv *prv)
{
(void)memset_s(&prv->key.rsaPrv, sizeof(prv->key.rsaPrv), 0, sizeof(prv->key.rsaPrv));
prv->key.rsaPrv.n = CMVP_StringsToBins(n, &(prv->key.rsaPrv.nLen));
GOTO_ERR_IF_TRUE(prv->key.rsaPrv.n == NULL, CRYPT_CMVP_COMMON_ERR);
prv->key.rsaPrv.d = CMVP_StringsToBins(d, &(prv->key.rsaPrv.dLen));
GOTO_ERR_IF_TRUE(prv->key.rsaPrv.d == NULL, CRYPT_CMVP_COMMON_ERR);
prv->id = CRYPT_PKEY_RSA;
return true;
ERR:
return false;
}
static bool GetPubKey(const char *n, const char *e, CRYPT_EAL_PkeyPub *pub)
{
pub->key.rsaPub.n = CMVP_StringsToBins(n, &(pub->key.rsaPub.nLen));
GOTO_ERR_IF_TRUE(pub->key.rsaPub.n == NULL, CRYPT_CMVP_COMMON_ERR);
pub->key.rsaPub.e = CMVP_StringsToBins(e, &(pub->key.rsaPub.eLen));
GOTO_ERR_IF_TRUE(pub->key.rsaPub.e == NULL, CRYPT_CMVP_COMMON_ERR);
pub->id = CRYPT_PKEY_RSA;
return true;
ERR:
return false;
}
static bool SetPkcsv15Pad(CRYPT_EAL_PkeyCtx *pkey, uint32_t *hashId)
{
*hashId = RSA_VECTOR[PKCSV15_PAD].mdId;
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, hashId, sizeof(uint32_t)) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
return true;
ERR:
return false;
}
static bool SetPssPad(CRYPT_EAL_PkeyCtx *pkey, uint32_t saltLen)
{
uint32_t mdId = RSA_VECTOR[PSS_PAD].mdId;
uint32_t mgfId = RSA_VECTOR[PSS_PAD].mdId;
BSL_Param pss[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, (void *)(uintptr_t)&mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, (void *)(uintptr_t)&mgfId, sizeof(mgfId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, (void *)(uintptr_t)&saltLen, sizeof(saltLen), 0},
BSL_PARAM_END
};
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_EMSA_PSS, pss, 0) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
return true;
ERR:
return false;
}
static bool RsaSelftestSign(void *libCtx, const char *attrName, int32_t id)
{
bool ret = false;
uint8_t *salt = NULL;
uint32_t pkcsv15;
CRYPT_EAL_PkeyPrv prv = { 0 };
CRYPT_EAL_PkeyCtx *pkey = NULL;
uint8_t *msg = NULL;
uint8_t *expectSign = NULL;
uint8_t *sign = NULL;
uint32_t msgLen, expectSignLen, signLen, saltLen;
msg = CMVP_StringsToBins(RSA_VECTOR[id].msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
expectSign = CMVP_StringsToBins(RSA_VECTOR[id].sign, &expectSignLen);
GOTO_ERR_IF_TRUE(expectSign == NULL, CRYPT_CMVP_COMMON_ERR);
pkey = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_RSA, 0, attrName);
GOTO_ERR_IF_TRUE(pkey == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(GetPrvKey(RSA_VECTOR[id].n, RSA_VECTOR[id].d, &prv) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(pkey, &prv) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
signLen = CRYPT_EAL_PkeyGetSignLen(pkey);
sign = BSL_SAL_Malloc(sizeof(uint32_t) * signLen);
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_MEM_ALLOC_FAIL);
if (id == PKCSV15_PAD) {
GOTO_ERR_IF_TRUE(!SetPkcsv15Pad(pkey, &pkcsv15), CRYPT_CMVP_ERR_ALGO_SELFTEST);
} else {
salt = CMVP_StringsToBins(RSA_VECTOR[PSS_PAD].salt, &(saltLen));
GOTO_ERR_IF_TRUE(salt == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(!SetPssPad(pkey, saltLen), CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_RSA_SALT, salt, saltLen) !=
CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySign(pkey, RSA_VECTOR[id].mdId, msg, msgLen, sign, &signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(signLen != expectSignLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(expectSign, sign, signLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(salt);
BSL_SAL_Free(msg);
BSL_SAL_Free(sign);
BSL_SAL_Free(expectSign);
BSL_SAL_Free(prv.key.rsaPrv.n);
BSL_SAL_Free(prv.key.rsaPrv.d);
CRYPT_EAL_PkeyFreeCtx(pkey);
return ret;
}
static bool RsaSelftestVerify(void *libCtx, const char *attrName, int32_t id)
{
bool ret = false;
uint8_t *salt = NULL;
uint32_t mdId;
CRYPT_EAL_PkeyPub pub = { 0 };
uint8_t *msg = NULL;
uint8_t *sign = NULL;
uint32_t signLen, msgLen, saltLen;
CRYPT_EAL_PkeyCtx *pkey = NULL;
msg = CMVP_StringsToBins(RSA_VECTOR[id].msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
sign = CMVP_StringsToBins(RSA_VECTOR[id].sign, &signLen);
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_CMVP_COMMON_ERR);
pkey = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_RSA, 0, attrName);
GOTO_ERR_IF_TRUE(pkey == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(GetPubKey(RSA_VECTOR[id].n, RSA_VECTOR[id].e, &pub) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(pkey, &pub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
if (id == PKCSV15_PAD) {
GOTO_ERR_IF_TRUE(!SetPkcsv15Pad(pkey, &mdId), CRYPT_CMVP_ERR_ALGO_SELFTEST);
} else {
salt = CMVP_StringsToBins(RSA_VECTOR[PSS_PAD].salt, &(saltLen));
GOTO_ERR_IF_TRUE(salt == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(!SetPssPad(pkey, saltLen), CRYPT_CMVP_ERR_ALGO_SELFTEST);
}
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyVerify(pkey, RSA_VECTOR[id].mdId, msg, msgLen, sign, signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(salt);
BSL_SAL_Free(msg);
BSL_SAL_Free(sign);
BSL_SAL_Free(pub.key.rsaPub.n);
BSL_SAL_Free(pub.key.rsaPub.e);
CRYPT_EAL_PkeyFreeCtx(pkey);
return ret;
}
static int32_t SetRandomVector(const char *vector, uint8_t *r, uint32_t rLen)
{
uint8_t *rand = NULL;
uint32_t randLen;
rand = CMVP_StringsToBins(vector, &randLen);
if (rand == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
if (randLen < rLen) {
BSL_SAL_FREE(rand);
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
(void)memcpy_s(r, rLen, rand, rLen);
BSL_SAL_FREE(rand);
return CRYPT_SUCCESS;
}
static int32_t TestVectorRandom(uint8_t *r, uint32_t rLen)
{
return SetRandomVector(RSA_ENC_DEC_VECTOR.seed, r, rLen);
}
static bool RsaSelftestEncrypt(void *libCtx, const char *attrName, const uint8_t *plain, const uint32_t plainLen,
const uint8_t *cipher, const uint32_t cipherLen)
{
bool ret = false;
CRYPT_EAL_PkeyCtx *pubCtx = NULL;
CRYPT_EAL_PkeyPub pub = { 0 };
uint8_t cipherText[MAX_CIPHER_TEXT_LEN] = {0};
uint32_t cipherTextLen = sizeof(cipherText);
int32_t err = CRYPT_CMVP_ERR_ALGO_SELFTEST;
uint32_t mdId = RSA_ENC_DEC_VECTOR.mdId;
BSL_Param oaep[3] = {{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
BSL_PARAM_END
};
CRYPT_EAL_RandFunc func = CRYPT_RandRegistGet();
CRYPT_EAL_RandFuncEx funcEx = CRYPT_RandRegistExGet();
CRYPT_RandRegistEx(NULL);
CRYPT_RandRegist(TestVectorRandom);
// encrypt
pubCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_RSA, 0, attrName);
GOTO_ERR_IF_TRUE(pubCtx == NULL, err);
GOTO_ERR_IF_TRUE(GetPubKey(RSA_ENC_DEC_VECTOR.n, RSA_ENC_DEC_VECTOR.e, &pub) != true, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(pubCtx, &pub) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(pubCtx, CRYPT_CTRL_SET_RSA_RSAES_OAEP, oaep, 0) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyEncrypt(pubCtx, plain, plainLen, cipherText, &cipherTextLen) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(cipherTextLen != cipherLen, err);
GOTO_ERR_IF_TRUE(memcmp(cipher, cipherText, cipherTextLen) != 0, err);
ret = true;
ERR:
CRYPT_RandRegist(func);
CRYPT_RandRegistEx(funcEx);
CRYPT_EAL_PkeyFreeCtx(pubCtx);
BSL_SAL_Free(pub.key.rsaPub.n);
BSL_SAL_Free(pub.key.rsaPub.e);
return ret;
}
static bool RsaSelftestDecrypt(void *libCtx, const char *attrName, const uint8_t *cipher, const uint32_t cipherLen,
const uint8_t *plain, const uint32_t plainLen)
{
bool ret = false;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
CRYPT_EAL_PkeyPrv prv = { 0 };
uint8_t plainText[MAX_CIPHER_TEXT_LEN] = {0};
uint32_t plainTextLen = sizeof(plainText);
int32_t err = CRYPT_CMVP_ERR_ALGO_SELFTEST;
uint32_t mdId = RSA_ENC_DEC_VECTOR.mdId;
BSL_Param oaep[3] = {{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdId, sizeof(mdId), 0},
BSL_PARAM_END
};
// decrypt
prvCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_RSA, 0, attrName);
GOTO_ERR_IF_TRUE(prvCtx == NULL, err);
GOTO_ERR_IF_TRUE(GetPrvKey(RSA_ENC_DEC_VECTOR.n, RSA_ENC_DEC_VECTOR.d, &prv) != true, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(prvCtx, &prv) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(prvCtx, CRYPT_CTRL_SET_RSA_RSAES_OAEP, oaep, 0) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(
CRYPT_EAL_PkeyDecrypt(prvCtx, cipher, cipherLen, plainText, &plainTextLen) != CRYPT_SUCCESS, err);
GOTO_ERR_IF_TRUE(plainTextLen != plainLen, err);
GOTO_ERR_IF_TRUE(memcmp(plain, plainText, plainTextLen) != 0, err);
ret = true;
ERR:
CRYPT_EAL_PkeyFreeCtx(prvCtx);
BSL_SAL_Free(prv.key.rsaPrv.n);
BSL_SAL_Free(prv.key.rsaPrv.d);
return ret;
}
static bool RsaSelftestEncryptDecrypt(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *plain = NULL;
uint32_t plainLen;
uint8_t *cipher = NULL;
uint32_t cipherLen;
plain = CMVP_StringsToBins(RSA_ENC_DEC_VECTOR.msg, &plainLen);
GOTO_ERR_IF_TRUE(plain == NULL, CRYPT_CMVP_COMMON_ERR);
cipher = CMVP_StringsToBins(RSA_ENC_DEC_VECTOR.cipher, &cipherLen);
GOTO_ERR_IF_TRUE(cipher == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(
RsaSelftestEncrypt(libCtx, attrName, plain, plainLen, cipher, cipherLen) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(
RsaSelftestDecrypt(libCtx, attrName, cipher, cipherLen, plain, plainLen) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(plain);
BSL_SAL_Free(cipher);
return ret;
}
bool CRYPT_CMVP_SelftestProviderRsa(void *libCtx, const char *attrName)
{
GOTO_ERR_IF_TRUE(RsaSelftestSign(libCtx, attrName, PKCSV15_PAD) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(RsaSelftestVerify(libCtx, attrName, PKCSV15_PAD) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(RsaSelftestSign(libCtx, attrName, PSS_PAD) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(RsaSelftestVerify(libCtx, attrName, PSS_PAD) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(RsaSelftestEncryptDecrypt(libCtx, attrName) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
return true;
ERR:
return false;
}
bool CRYPT_CMVP_SelftestRsa(void)
{
GOTO_ERR_IF_TRUE(RsaSelftestSign(NULL, NULL, PKCSV15_PAD) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(RsaSelftestVerify(NULL, NULL, PKCSV15_PAD) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(RsaSelftestSign(NULL, NULL, PSS_PAD) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(RsaSelftestVerify(NULL, NULL, PSS_PAD) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(RsaSelftestEncryptDecrypt(NULL, NULL) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
return true;
ERR:
return false;
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_rsa.c | C | unknown | 21,532 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_kdf.h"
#include "crypt_params_key.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
const char *pw;
const char *salt;
uint32_t n;
uint32_t r;
uint32_t p;
const char *key;
} CMVP_SCRYPT_VECTOR;
// https://datatracker.ietf.org/doc/html/rfc7914#page-13
static const CMVP_SCRYPT_VECTOR SCRYPT_VECTOR = {
.pw = "70617373776f7264",
.salt = "4e61436c",
.n = 1024,
.r = 8,
.p = 16,
.key = "fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b3731622eaf30d92e22a388"
"6ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640"
};
static bool CRYPT_CMVP_SelftestScryptInternal(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *pw = NULL;
uint8_t *salt = NULL;
uint8_t *key = NULL;
uint8_t *expkey = NULL;
uint32_t pwLen, saltLen, expkeyLen;
uint32_t n = SCRYPT_VECTOR.n;
uint32_t r = SCRYPT_VECTOR.r;
uint32_t p = SCRYPT_VECTOR.p;
CRYPT_EAL_KdfCTX *ctx = NULL;
pw = CMVP_StringsToBins(SCRYPT_VECTOR.pw, &pwLen);
GOTO_ERR_IF_TRUE(pw == NULL, CRYPT_CMVP_COMMON_ERR);
salt = CMVP_StringsToBins(SCRYPT_VECTOR.salt, &saltLen);
GOTO_ERR_IF_TRUE(salt == NULL, CRYPT_CMVP_COMMON_ERR);
expkey = CMVP_StringsToBins(SCRYPT_VECTOR.key, &expkeyLen);
GOTO_ERR_IF_TRUE(expkey == NULL, CRYPT_CMVP_COMMON_ERR);
key = BSL_SAL_Malloc(expkeyLen);
GOTO_ERR_IF_TRUE(key == NULL, CRYPT_MEM_ALLOC_FAIL);
ctx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_SCRYPT, attrName);
GOTO_ERR_IF_TRUE(ctx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
BSL_Param param[6] = {
{CRYPT_PARAM_KDF_PASSWORD, BSL_PARAM_TYPE_OCTETS, pw, pwLen, 0},
{CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS, salt, saltLen, 0},
{CRYPT_PARAM_KDF_N, BSL_PARAM_TYPE_UINT32, &n, sizeof(uint32_t), 0},
{CRYPT_PARAM_KDF_R, BSL_PARAM_TYPE_UINT32, &r, sizeof(uint32_t), 0},
{CRYPT_PARAM_KDF_P, BSL_PARAM_TYPE_UINT32, &p, sizeof(uint32_t), 0},
BSL_PARAM_END
};
GOTO_ERR_IF_TRUE(CRYPT_EAL_KdfSetParam(ctx, param) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_KdfDerive(ctx, key, expkeyLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(key, expkey, expkeyLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(pw);
BSL_SAL_Free(salt);
BSL_SAL_Free(expkey);
BSL_SAL_Free(key);
CRYPT_EAL_KdfFreeCtx(ctx);
return ret;
}
bool CRYPT_CMVP_SelftestScrypt(void)
{
return CRYPT_CMVP_SelftestScryptInternal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderScrypt(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestScryptInternal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_scrypt.c | C | unknown | 3,597 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_algid.h"
#include "crypt_eal_pkey.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "securec.h"
#include "bsl_sal.h"
#define BITS_OF_BYTE 8
typedef struct {
const char *rnd;
const char *sk;
const char *pk;
const char *context;
const char *msg;
const char *sig;
int32_t preHashId;
int32_t algId;
int32_t type;
} CMVP_SlhdsaSignVector;
static const CMVP_SlhdsaSignVector SLHDSA_VECTOR[] = {
{
// https://github.com/usnistgov/ACVP-Server/tree/master/gen-val/json-files/SLH-DSA-sigGen-FIPS205
.rnd = "FD3FE9ADC298FAD0BF5A08D804C690B1",
.sk = "F9FFBDE3D5FB47C2669823076777A941B810BE27FEF66DD4353B4A21DC972842EA5EE0F3E9B301B5CC32814C8AC6CDBD8BE5D429B0104F2F0A929099F687A74C",
.pk = "EA5EE0F3E9B301B5CC32814C8AC6CDBD8BE5D429B0104F2F0A929099F687A74C",
.context = "F29200E32E0DCCC92F029503DF3C878E340569C54169A31F7704A16EEBDF5667D0A5DB865F486F67052B1765B772D461C9F4B75B2D6056CD185F2C9D74D1F446674D75B49D5082EC6097269837BC7FA3A2163FE026BEB4455A79D7E135D0FF2BC44E213715767808D4DD1AE2A6B147F041616D74FDB89589848B2B155957CA7B79CC497EACC1050F8A3C98BB4839D1858F",
.msg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
.sig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
.algId = CRYPT_PKEY_SLH_DSA,
.preHashId = CRYPT_MD_SHA256,
.type = CRYPT_SLH_DSA_SHA2_128F,
}
};
static int32_t GetPkey(void *libCtx, const char *attrName, const CMVP_SlhdsaSignVector *vector,
CRYPT_EAL_PkeyCtx **pkeyPrv, CRYPT_EAL_PkeyCtx **pkeyPub)
{
int32_t ret = CRYPT_CMVP_ERR_ALGO_SELFTEST;
CRYPT_EAL_PkeyPrv prvKey = { 0 };
uint8_t *rand = NULL;
uint8_t *vectorKey = NULL;
uint8_t *context = NULL;
*pkeyPrv = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, vector->algId, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPrv == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
*pkeyPub = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, vector->algId, 0, attrName);
GOTO_ERR_IF_TRUE(*pkeyPub == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = CRYPT_EAL_PkeySetParaById(*pkeyPrv, vector->type);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
ret = CRYPT_EAL_PkeySetParaById(*pkeyPub, vector->type);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
uint32_t keyLen = 0;
ret = CRYPT_EAL_PkeyCtrl(*pkeyPrv, CRYPT_CTRL_GET_SLH_DSA_KEY_LEN, (void *)&keyLen, sizeof(keyLen));
uint32_t randLen = 0;
rand = CMVP_StringsToBins(vector->rnd, &randLen);
ret = CRYPT_EAL_PkeyCtrl(*pkeyPrv, CRYPT_CTRL_SET_SLH_DSA_ADDRAND, (void *)rand, randLen);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
uint32_t vectorKeyLen = 0;
vectorKey = CMVP_StringsToBins(vector->sk, &vectorKeyLen);
prvKey.id = CRYPT_PKEY_SLH_DSA;
prvKey.key.slhDsaPrv.seed = vectorKey;
prvKey.key.slhDsaPrv.prf = vectorKey + keyLen;
prvKey.key.slhDsaPrv.pub.seed = vectorKey + keyLen * 2; // 2: pub.seed offset
prvKey.key.slhDsaPrv.pub.root = vectorKey + keyLen * 3; // 3: pub.root offset
prvKey.key.slhDsaPrv.pub.len = keyLen;
ret = CRYPT_EAL_PkeySetPrv(*pkeyPrv, &prvKey);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
uint32_t contextLen = 0;
context = CMVP_StringsToBins(vector->context, &contextLen);
ret = CRYPT_EAL_PkeyCtrl(*pkeyPrv, CRYPT_CTRL_SET_CTX_INFO, context, contextLen);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
ret = CRYPT_EAL_PkeyCtrl(*pkeyPub, CRYPT_CTRL_SET_SLH_DSA_ADDRAND, (void *)rand, randLen);
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
ret = CRYPT_EAL_PkeySetPrv(*pkeyPub, &prvKey); // The prvKey contains the public key, public key is used here.
GOTO_ERR_IF_TRUE(ret != CRYPT_SUCCESS, ret);
ret = CRYPT_EAL_PkeyCtrl(*pkeyPub, CRYPT_CTRL_SET_CTX_INFO, context, contextLen);
ERR:
BSL_SAL_Free(rand);
BSL_SAL_Free(vectorKey);
BSL_SAL_Free(context);
return ret;
}
static bool TestSlhdsaSignVerify(void *libCtx, const char *attrName, const CMVP_SlhdsaSignVector *vector)
{
bool ret = false;
uint8_t *sign = NULL;
uint8_t *signVec = NULL;
uint32_t signLen;
uint32_t signVecLen = 0;
uint8_t *msg = NULL;
uint32_t msgLen;
CRYPT_EAL_PkeyCtx *pkeyPrv = NULL;
CRYPT_EAL_PkeyCtx *pkeyPub = NULL;
GOTO_ERR_IF_TRUE(
GetPkey(libCtx, attrName, vector, &pkeyPrv, &pkeyPub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
msg = CMVP_StringsToBins(vector->msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
signVec = CMVP_StringsToBins(vector->sig, &signVecLen);
GOTO_ERR_IF_TRUE(signVec == NULL, CRYPT_CMVP_COMMON_ERR);
signLen = signVecLen;
sign = BSL_SAL_Malloc(signLen);
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_MEM_ALLOC_FAIL);
// sign
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySign(pkeyPrv, vector->preHashId, msg, msgLen, sign, &signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
// compare the signature
GOTO_ERR_IF_TRUE(signLen != signVecLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(signVec, sign, signLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
// verify
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyVerify(pkeyPub, vector->preHashId, msg, msgLen, sign, signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(sign);
BSL_SAL_Free(signVec);
BSL_SAL_Free(msg);
CRYPT_EAL_PkeyFreeCtx(pkeyPrv);
CRYPT_EAL_PkeyFreeCtx(pkeyPub);
return ret;
}
bool CRYPT_CMVP_SelftestSlhdsaSignVerify(void)
{
bool ret = TestSlhdsaSignVerify(NULL, NULL, &SLHDSA_VECTOR[0]);
return ret;
}
bool CRYPT_CMVP_SelftestProviderSlhdsaSignVerify(void *libCtx, const char *attrName)
{
return TestSlhdsaSignVerify(libCtx, attrName, &SLHDSA_VECTOR[0]);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */ | 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_slhdsa.c | C | unknown | 57,044 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_SM) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "securec.h"
#include "crypt_bn.h"
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "crypt_bn.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
#include "crypt_eal_rand.h"
#include "crypt_encode_internal.h"
#include "crypt_util_rand.h"
#define BITS_OF_BYTE 8
#define MAX_PLAIN_TEXT_LEN 19
#define CIPHER_TEXT_EXTRA_LEN 108
#define SM3_MD_SIZE 32
#define SM2_POINT_SINGLE_COORDINATE_LEN 32
#define SM2_POINT_COORDINATE_LEN 65
const char *consistestdata = "01020304050607080910";
typedef struct {
const char *d;
const char *qX;
const char *qY;
} CMVP_SM2_KEYS;
static const CMVP_SM2_KEYS SM2_TEST_KEYS = {
.d = "3945208f7b2144b13f36e38ac6d39f95889393692860b51a42fb81ef4df7c5b8",
.qX = "09f9df311e5421a150dd7d161e4bc5c672179fad1833fc076bb08ff356f35020",
.qY = "ccea490ce26775a52dc6ea718cc1aa600aed05fbf35e084a6632f6072da9ad13",
};
typedef struct {
const char *plain;
const char *cipher;
const char *k;
int32_t curveId;
CRYPT_MD_AlgId mdId;
} CMVP_SM2CryptVector;
static const CMVP_SM2CryptVector SM2_CRYPT_TEST_VECTOR = {
.plain = "656e6372797074696f6e207374616e64617264",
.k = "59276e27d506861a16680f3ad9c02dccef3cc1fa3cdbe4ce6d54b80deac1bc21",
.cipher = "0404ebfc718e8d1798620432268e77feb6415e2ede0e073c0f4f640ecd2e149a73e858f9d81e5430a57b36daab8f950a3c64e6ee6a63094d99283aff767e124df059983c18f809e262923c53aec295d30383b54e39d609d160afcb1908d0bd876621886ca989ca9c7d58087307ca93092d651efa",
};
typedef struct {
const char *msg;
const char *k;
const char *signR;
const char *signS;
const char *userid;
int32_t curveId;
CRYPT_MD_AlgId mdId;
} CMVP_SM2SignVector;
static const CMVP_SM2SignVector SM2DSA_VECTOR = {
.msg = "6d65737361676520646967657374",
.k = "59276e27d506861a16680f3ad9c02dccef3cc1fa3cdbe4ce6d54b80deac1bc21",
.signR = "f5a03b0648d2c4630eeac513e1bb81a15944da3827d5b74143ac7eaceee720b3",
.signS = "b1b6aa29df212fd8763182bc0d421ca1bb9038fd1f7f42d4840b69c485bbc1aa",
.userid = "31323334353637383132333435363738",
.curveId = CRYPT_ECC_SM2,
.mdId = CRYPT_MD_SM3
};
typedef struct {
const char *self_d;
const char *self_x;
const char *self_y;
const char *peer_d;
const char *peer_x;
const char *peer_y;
const char *r;
const char *R;
const char *sharekey;
const char *userid1;
const char *userid2;
int32_t server;
} CMVP_SM2ExchangeVector;
static const CMVP_SM2ExchangeVector SM2Exchange_VECTOR = {
.self_d = "81eb26e941bb5af16df116495f90695272ae2cd63d6c4ae1678418be48230029",
.self_x = "160e12897df4edb61dd812feb96748fbd3ccf4ffe26aa6f6db9540af49c94232",
.self_y = "4a7dad08bb9a459531694beb20aa489d6649975e1bfcf8c4741b78b4b223007f",
.peer_d = "785129917d45a9ea5437a59356b82338eaadda6ceb199088f14ae10defa229b5",
.peer_x = "6ae848c57c53c7b1b5fa99eb2286af078ba64c64591b8b566f7357d576f16dfb",
.peer_y = "ee489d771621a27b36c5c7992062e9cd09a9264386f3fbea54dff69305621c4d",
.r = "d4de15474db74d06491c440d305e012400990f3e390c7e87153c12db2ea60bb3",
.R = "04acc27688a6f7b706098bc91ff3ad1bff7dc2802cdb14ccccdb0a90471f9bd7072fedac0494b2ffc4d6853876c79b8f301c6573ad0aa50f39fc87181e1a1b46fe",
.sharekey = "6c89347354de2484c60b4ab1fde4c6e5",
.userid1 = "31323334353637383132333435363738",
.userid2 = "31323334353637383132333435363738",
};
static int32_t SetRandomVector(const char *vector, uint8_t *r, uint32_t rLen)
{
uint8_t *rand = NULL;
uint32_t randLen;
rand = CMVP_StringsToBins(vector, &randLen);
if (rand == NULL) {
return CRYPT_MEM_ALLOC_FAIL;
}
if (randLen < rLen) {
BSL_SAL_FREE(rand);
return CRYPT_CMVP_ERR_ALGO_SELFTEST;
}
(void)memcpy_s(r, rLen, rand, rLen);
BSL_SAL_FREE(rand);
return CRYPT_SUCCESS;
}
static int32_t TestVectorRandom(uint8_t *r, uint32_t rLen)
{
return SetRandomVector(SM2DSA_VECTOR.k, r, rLen);
}
static bool SetPrvPkey(CRYPT_EAL_PkeyCtx **pkeyPrv, const char qd[])
{
bool ret = false;
uint8_t *d = NULL;
uint32_t dLen;
CRYPT_EAL_PkeyPrv prv = {0};
prv.id = CRYPT_PKEY_SM2;
d = CMVP_StringsToBins(qd, &dLen);
GOTO_ERR_IF_TRUE(d == NULL, CRYPT_CMVP_COMMON_ERR);
prv.key.eccPrv.len = dLen;
prv.key.eccPrv.data = BSL_SAL_Malloc(prv.key.eccPrv.len);
GOTO_ERR_IF_TRUE(prv.key.eccPrv.data == NULL, CRYPT_MEM_ALLOC_FAIL);
GOTO_ERR_IF_TRUE(memcpy_s(prv.key.eccPrv.data, prv.key.eccPrv.len, d, dLen) != EOK, CRYPT_SECUREC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(*pkeyPrv, &prv) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_FREE(prv.key.eccPrv.data);
BSL_SAL_FREE(d);
return ret;
}
static bool SetPubPkey(CRYPT_EAL_PkeyCtx **pkeyPub, const char qX[], const char qY[])
{
bool ret = false;
CRYPT_EAL_PkeyPub pub = {0};
uint8_t *x = NULL;
uint8_t *y = NULL;
uint32_t xLen, yLen;
pub.id = CRYPT_PKEY_SM2;
x = CMVP_StringsToBins(qX, &xLen);
GOTO_ERR_IF_TRUE(x == NULL, CRYPT_CMVP_COMMON_ERR);
y = CMVP_StringsToBins(qY, &yLen);
GOTO_ERR_IF_TRUE(y == NULL, CRYPT_CMVP_COMMON_ERR);
pub.key.eccPub.len = xLen + yLen + 1;
pub.key.eccPub.data = BSL_SAL_Malloc(pub.key.eccPub.len);
GOTO_ERR_IF_TRUE(pub.key.eccPub.data == NULL, CRYPT_MEM_ALLOC_FAIL);
pub.key.eccPub.data[0] = 0x04;
GOTO_ERR_IF_TRUE(memcpy_s(pub.key.eccPub.data + 1, pub.key.eccPub.len, x, xLen) != EOK, CRYPT_SECUREC_FAIL);
GOTO_ERR_IF_TRUE(memcpy_s(pub.key.eccPub.data + 1 + xLen, pub.key.eccPub.len, y, yLen) != EOK, CRYPT_SECUREC_FAIL);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(*pkeyPub, &pub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_FREE(pub.key.eccPub.data);
BSL_SAL_FREE(x);
BSL_SAL_FREE(y);
return ret;
}
bool CRYPT_CMVP_SelftestSM2Crypt(void *libCtx, const char *attrName)
{
bool ret = false;
CRYPT_EAL_PkeyCtx *pubCtx = NULL;
CRYPT_EAL_PkeyCtx *prvCtx = NULL;
uint8_t *plain = NULL;
uint32_t plainLen;
uint8_t *cipher = NULL;
uint32_t cipherLen;
uint8_t cipherText[MAX_PLAIN_TEXT_LEN + CIPHER_TEXT_EXTRA_LEN] = {0};
uint32_t cipherTextLen = sizeof(cipherText);
uint8_t decodeText[MAX_PLAIN_TEXT_LEN + CIPHER_TEXT_EXTRA_LEN] = {0};
uint32_t decodeoutLen = sizeof(decodeText);
uint8_t plainText[MAX_PLAIN_TEXT_LEN] = {0};
uint32_t plainTextLen = sizeof(plainText);
uint8_t encodeText[MAX_PLAIN_TEXT_LEN + CIPHER_TEXT_EXTRA_LEN] = {0};
uint32_t encodeTextLen = sizeof(encodeText);
CRYPT_EAL_RandFunc func = CRYPT_RandRegistGet();
CRYPT_EAL_RandFuncEx funcEx = CRYPT_RandRegistExGet();
CRYPT_RandRegistEx(NULL);
pubCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_SM2, 0, attrName);
GOTO_ERR_IF_TRUE(pubCtx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
prvCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_SM2, 0, attrName);
GOTO_ERR_IF_TRUE(prvCtx == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
SetPrvPkey(&prvCtx, SM2_TEST_KEYS.d);
SetPubPkey(&pubCtx, SM2_TEST_KEYS.qX, SM2_TEST_KEYS.qY);
plain = CMVP_StringsToBins(SM2_CRYPT_TEST_VECTOR.plain, &plainLen);
GOTO_ERR_IF_TRUE(plain == NULL, CRYPT_CMVP_COMMON_ERR);
cipher = CMVP_StringsToBins(SM2_CRYPT_TEST_VECTOR.cipher, &cipherLen);
GOTO_ERR_IF_TRUE(cipher == NULL, CRYPT_CMVP_COMMON_ERR);
CRYPT_RandRegist(TestVectorRandom);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyEncrypt(pubCtx, plain, plainLen, cipherText, &cipherTextLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
CRYPT_SM2_EncryptData data = {
.x = decodeText + 1,
.xLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.y = decodeText + SM2_POINT_SINGLE_COORDINATE_LEN + 1,
.yLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.hash = decodeText + SM2_POINT_COORDINATE_LEN,
.hashLen = SM3_MD_SIZE,
.cipher = decodeText + SM2_POINT_COORDINATE_LEN + SM3_MD_SIZE,
.cipherLen = decodeoutLen - SM2_POINT_COORDINATE_LEN - SM3_MD_SIZE
};
GOTO_ERR_IF_TRUE(CRYPT_EAL_DecodeSm2EncryptData(cipherText, cipherTextLen, &data) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
decodeText[0] = 0x04;
decodeoutLen = SM2_POINT_SINGLE_COORDINATE_LEN + SM2_POINT_SINGLE_COORDINATE_LEN + SM3_MD_SIZE + data.cipherLen;
GOTO_ERR_IF_TRUE(decodeoutLen + 1 != cipherLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(decodeText, cipher, cipherLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_EncodeSm2EncryptData(&data, encodeText, &encodeTextLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(
CRYPT_EAL_PkeyDecrypt(prvCtx, encodeText, encodeTextLen, plainText, &plainTextLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(plainTextLen != plainLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(plainText, plain, plainLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_FREE(plain);
BSL_SAL_FREE(cipher);
CRYPT_RandRegist(func);
CRYPT_RandRegistEx(funcEx);
CRYPT_EAL_PkeyFreeCtx(pubCtx);
CRYPT_EAL_PkeyFreeCtx(prvCtx);
return ret;
}
static int32_t SignEncode(const char *signR, const char *signS, uint8_t *vectorSign, uint32_t *vectorSignLen)
{
int ret = CRYPT_CMVP_ERR_ALGO_SELFTEST;
BN_BigNum *bnR = NULL;
BN_BigNum *bnS = NULL;
uint8_t *r = NULL;
uint8_t *s = NULL;
uint32_t rLen, sLen;
r = CMVP_StringsToBins(signR, &rLen);
GOTO_ERR_IF_TRUE(r == NULL, CRYPT_CMVP_COMMON_ERR);
s = CMVP_StringsToBins(signS, &sLen);
GOTO_ERR_IF_TRUE(s == NULL, CRYPT_CMVP_COMMON_ERR);
bnR = BN_Create(rLen * BITS_OF_BYTE);
bnS = BN_Create(sLen * BITS_OF_BYTE);
GOTO_ERR_IF_TRUE(BN_Bin2Bn(bnR, r, rLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(BN_Bin2Bn(bnS, s, sLen) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = CRYPT_EAL_EncodeSign(bnR, bnS, vectorSign, vectorSignLen);
ERR:
BSL_SAL_FREE(r);
BSL_SAL_FREE(s);
BN_Destroy(bnR);
BN_Destroy(bnS);
return ret;
}
static bool SetUserId(CRYPT_EAL_PkeyCtx *pkey, const char id[])
{
bool ret = false;
uint8_t *userId = NULL;
uint32_t userIdLen;
userId = CMVP_StringsToBins(id, &(userIdLen));
GOTO_ERR_IF_TRUE(userId == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_SET_SM2_USER_ID, userId, userIdLen) != CRYPT_SUCCESS,
CRYPT_CMVP_COMMON_ERR);
ret = true;
ERR:
BSL_SAL_FREE(userId);
return ret;
}
bool CRYPT_CMVP_SelftestSM2Sign(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *sign = NULL;
uint8_t *signVec = NULL;
uint32_t signLen;
uint32_t signVecLen = 0;
uint8_t *msg = NULL;
uint32_t msgLen;
CRYPT_EAL_PkeyCtx *pkeyPrv = NULL;
CRYPT_EAL_PkeyCtx *pkeyPub = NULL;
CRYPT_EAL_RandFunc func = CRYPT_RandRegistGet();
CRYPT_EAL_RandFuncEx funcEx = CRYPT_RandRegistExGet();
CRYPT_RandRegistEx(NULL);
msg = CMVP_StringsToBins(SM2DSA_VECTOR.msg, &msgLen);
GOTO_ERR_IF_TRUE(msg == NULL, CRYPT_CMVP_COMMON_ERR);
pkeyPrv = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_SM2, 0, attrName);
GOTO_ERR_IF_TRUE(pkeyPrv == NULL, CRYPT_CMVP_COMMON_ERR);
pkeyPub = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_SM2, 0, attrName);
GOTO_ERR_IF_TRUE(pkeyPub == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(SetUserId(pkeyPub, SM2DSA_VECTOR.userid) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetUserId(pkeyPrv, SM2DSA_VECTOR.userid) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetPrvPkey(&pkeyPrv, SM2_TEST_KEYS.d) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetPubPkey(&pkeyPub, SM2_TEST_KEYS.qX, SM2_TEST_KEYS.qY) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
signLen = CRYPT_EAL_PkeyGetSignLen(pkeyPrv);
sign = BSL_SAL_Malloc(signLen);
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_MEM_ALLOC_FAIL);
// regist rand function
CRYPT_RandRegist(TestVectorRandom);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySign(pkeyPrv, SM2DSA_VECTOR.mdId, msg, msgLen, sign, &signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
// compare the signature
signVecLen = CRYPT_EAL_PkeyGetSignLen(pkeyPrv);
signVec = (uint8_t *)BSL_SAL_Malloc(signVecLen);
GOTO_ERR_IF_TRUE(signVec == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(SignEncode(SM2DSA_VECTOR.signR, SM2DSA_VECTOR.signS, signVec, &signVecLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(signLen != signVecLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(signVec, sign, signLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(
CRYPT_EAL_PkeyVerify(pkeyPub, SM2DSA_VECTOR.mdId, msg, msgLen, signVec, signVecLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_FREE(sign);
BSL_SAL_FREE(signVec);
BSL_SAL_FREE(msg);
CRYPT_EAL_PkeyFreeCtx(pkeyPrv);
CRYPT_EAL_PkeyFreeCtx(pkeyPub);
CRYPT_RandRegist(func);
CRYPT_RandRegistEx(funcEx);
return ret;
}
static int32_t TestExchangeVectorRandom(uint8_t *r, uint32_t rLen)
{
return SetRandomVector(SM2Exchange_VECTOR.r, r, rLen);
}
bool CRYPT_CMVP_SelftestSM2Exchange(void *libCtx, const char *attrName)
{
bool ret = false;
uint8_t *R = NULL;
uint8_t *out = NULL;
uint8_t *sharekey = NULL;
uint8_t localR[65];
int32_t server = 1;
CRYPT_EAL_PkeyCtx *selfCtx = NULL;
CRYPT_EAL_PkeyCtx *peerCtx = NULL;
CRYPT_EAL_RandFunc func = CRYPT_RandRegistGet();
CRYPT_EAL_RandFuncEx funcEx = CRYPT_RandRegistExGet();
CRYPT_RandRegistEx(NULL);
selfCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_SM2, 0, attrName);
GOTO_ERR_IF_TRUE(selfCtx == NULL, CRYPT_CMVP_COMMON_ERR);
peerCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_SM2, 0, attrName);
GOTO_ERR_IF_TRUE(peerCtx == NULL, CRYPT_CMVP_COMMON_ERR);
uint32_t RLen;
R = CMVP_StringsToBins(SM2Exchange_VECTOR.R, &RLen);
GOTO_ERR_IF_TRUE(R == NULL, CRYPT_CMVP_COMMON_ERR);
uint32_t sharekeyLen;
sharekey = CMVP_StringsToBins(SM2Exchange_VECTOR.sharekey, &sharekeyLen);
GOTO_ERR_IF_TRUE(sharekey == NULL, CRYPT_CMVP_COMMON_ERR);
uint32_t outLen = sharekeyLen;
out = BSL_SAL_Malloc(outLen);
GOTO_ERR_IF_TRUE(out == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(SetUserId(selfCtx, SM2Exchange_VECTOR.userid1) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(selfCtx, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(int32_t)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
CRYPT_RandRegist(TestExchangeVectorRandom);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(selfCtx, CRYPT_CTRL_GENE_SM2_R, localR, sizeof(localR)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetUserId(peerCtx, SM2Exchange_VECTOR.userid2) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyCtrl(peerCtx, CRYPT_CTRL_SET_SM2_R, R, RLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetPrvPkey(&selfCtx, SM2Exchange_VECTOR.self_d) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetPrvPkey(&peerCtx, SM2Exchange_VECTOR.peer_d) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetPubPkey(&selfCtx, SM2Exchange_VECTOR.self_x, SM2Exchange_VECTOR.self_y) != true,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetPubPkey(&peerCtx, SM2Exchange_VECTOR.peer_x, SM2Exchange_VECTOR.peer_y) != true,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyComputeShareKey(selfCtx, peerCtx, out, &outLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(outLen != sharekeyLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(out, sharekey, sharekeyLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_FREE(sharekey);
BSL_SAL_FREE(out);
BSL_SAL_FREE(R);
CRYPT_EAL_PkeyFreeCtx(peerCtx);
CRYPT_EAL_PkeyFreeCtx(selfCtx);
CRYPT_RandRegist(func);
CRYPT_RandRegistEx(funcEx);
return ret;
}
static bool SM2_Consistency_Sign(void)
{
bool ret = false;
CRYPT_EAL_PkeyCtx *pkey = NULL;
uint8_t *sign = NULL;
uint32_t signLen;
uint8_t *data = NULL;
uint32_t dataLen;
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SM2);
GOTO_ERR_IF_TRUE(pkey == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(SetUserId(pkey, SM2DSA_VECTOR.userid) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
signLen = CRYPT_EAL_PkeyGetSignLen(pkey);
sign = BSL_SAL_Malloc(signLen);
GOTO_ERR_IF_TRUE(sign == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyGen(pkey) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
data = CMVP_StringsToBins(consistestdata, &dataLen);
GOTO_ERR_IF_TRUE(data == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySign(pkey, CRYPT_MD_SM3, data, dataLen, sign, &signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyVerify(pkey, CRYPT_MD_SM3, data, dataLen, sign, signLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_FREE(sign);
BSL_SAL_FREE(data);
CRYPT_EAL_PkeyFreeCtx(pkey);
return ret;
}
static bool SM2_Consistency_Crypt(void)
{
bool ret = false;
uint8_t *plain = NULL;
uint32_t plainLen;
uint8_t cipherText[MAX_PLAIN_TEXT_LEN + CIPHER_TEXT_EXTRA_LEN] = {0};
uint32_t cipherTextLen = sizeof(cipherText);
uint8_t decodeText[MAX_PLAIN_TEXT_LEN + CIPHER_TEXT_EXTRA_LEN] = {0};
uint32_t decodeTextLen = sizeof(decodeText);
uint8_t plainText[MAX_PLAIN_TEXT_LEN] = {0};
uint32_t plainTextLen = sizeof(plainText);
uint8_t encodeText[MAX_PLAIN_TEXT_LEN + CIPHER_TEXT_EXTRA_LEN] = {0};
uint32_t encodeTextLen = sizeof(encodeText);
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_SM2);
GOTO_ERR_IF_TRUE(pkey == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyGen(pkey) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
plain = CMVP_StringsToBins(SM2_CRYPT_TEST_VECTOR.plain, &plainLen);
GOTO_ERR_IF_TRUE(plain == NULL, CRYPT_CMVP_COMMON_ERR);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyEncrypt(pkey, plain, plainLen, cipherText, &cipherTextLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
CRYPT_SM2_EncryptData data = {
.x = decodeText+ 1,
.xLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.y = decodeText + SM2_POINT_SINGLE_COORDINATE_LEN + 1,
.yLen = SM2_POINT_SINGLE_COORDINATE_LEN,
.hash = decodeText + SM2_POINT_COORDINATE_LEN,
.hashLen = SM3_MD_SIZE,
.cipher = decodeText + SM2_POINT_COORDINATE_LEN + SM3_MD_SIZE,
.cipherLen = decodeTextLen - SM2_POINT_COORDINATE_LEN - SM3_MD_SIZE
};
GOTO_ERR_IF_TRUE(CRYPT_EAL_DecodeSm2EncryptData(cipherText, cipherTextLen, &data) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
decodeText[0] = 0x04;
GOTO_ERR_IF_TRUE(memcmp(decodeText, plain, plainLen) == 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_EncodeSm2EncryptData(&data, encodeText, &encodeTextLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyDecrypt(pkey, encodeText, encodeTextLen, plainText, &plainTextLen) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(plainTextLen != plainLen, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(plainText, plain, plainLen) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_FREE(plain);
CRYPT_EAL_PkeyFreeCtx(pkey);
return ret;
}
bool CRYPT_CMVP_SelftestSM2Consistency(void)
{
return SM2_Consistency_Sign() && SM2_Consistency_Crypt();
}
bool CRYPT_CMVP_SelftestSM2(void)
{
return CRYPT_CMVP_SelftestSM2Sign(NULL, NULL) && CRYPT_CMVP_SelftestSM2Crypt(NULL, NULL) &&
CRYPT_CMVP_SelftestSM2Exchange(NULL, NULL) && CRYPT_CMVP_SelftestSM2Consistency();
}
bool CRYPT_CMVP_SelftestProviderSM2(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestSM2Sign(libCtx, attrName) && CRYPT_CMVP_SelftestSM2Crypt(libCtx, attrName) &&
CRYPT_CMVP_SelftestSM2Exchange(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_SM || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_sm2.c | C | unknown | 21,294 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#if defined(HITLS_CRYPTO_CMVP_ISO19790) || defined(HITLS_CRYPTO_CMVP_FIPS)
#include <string.h>
#include "crypt_cmvp_selftest.h"
#include "cmvp_common.h"
#include "err.h"
#include "crypt_errno.h"
#include "crypt_eal_pkey.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "bsl_sal.h"
typedef struct {
const char *alicePri;
const char *alicePub;
const char *bobPri;
const char *bobPub;
const char *share1;
} CMVP_X25519_VECTOR;
// https://datatracker.ietf.org/doc/html/rfc7748.html#page-14
static const CMVP_X25519_VECTOR X25519_VECTOR = {
.alicePri = "77076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c2a",
.alicePub = "8520f0098930a754748b7ddcb43ef75a0dbf3a0d26381af4eba4a98eaa9b4e6a",
.bobPri = "5dab087e624a8a4b79e17f8b83800ee66f3bb1292618b6fd1c2f8b27ff88e0eb",
.bobPub = "de9edb7d7b7dc1b4d35b61c2ece435373f8343c85b78674dadfc7e146f882b4f",
.share1 = "4a5d9d5ba4ce2de1728e3bf480350f25e07e21c947d19e3376f09b3c1e161742"
};
static bool GetData(CRYPT_Data *expShare, CRYPT_Data *share1, CRYPT_Data *share2)
{
expShare->data = CMVP_StringsToBins(X25519_VECTOR.share1, &(expShare->len));
GOTO_ERR_IF_TRUE(expShare->data == NULL, CRYPT_CMVP_COMMON_ERR);
share1->len = expShare->len;
share1->data = BSL_SAL_Malloc(share1->len);
GOTO_ERR_IF_TRUE(share1->data == NULL, CRYPT_MEM_ALLOC_FAIL);
share2->len = expShare->len;
share2->data = BSL_SAL_Malloc(share2->len);
GOTO_ERR_IF_TRUE(share2->data == NULL, CRYPT_MEM_ALLOC_FAIL);
return true;
ERR:
return false;
}
static bool GetKey(CRYPT_EAL_PkeyPrv *alicePri, CRYPT_EAL_PkeyPub *alicePub, CRYPT_EAL_PkeyPrv *bobPri,
CRYPT_EAL_PkeyPub *bobPub)
{
alicePri->id = CRYPT_PKEY_X25519;
alicePri->key.curve25519Prv.data = CMVP_StringsToBins(X25519_VECTOR.alicePri, &(alicePri->key.curve25519Prv.len));
GOTO_ERR_IF_TRUE(alicePri->key.curve25519Prv.data == NULL, CRYPT_CMVP_COMMON_ERR);
alicePub->id = CRYPT_PKEY_X25519;
alicePub->key.curve25519Pub.data = CMVP_StringsToBins(X25519_VECTOR.alicePub, &(alicePub->key.curve25519Pub.len));
GOTO_ERR_IF_TRUE(alicePub->key.curve25519Pub.data == NULL, CRYPT_CMVP_COMMON_ERR);
bobPri->id = CRYPT_PKEY_X25519;
bobPri->key.curve25519Prv.data = CMVP_StringsToBins(X25519_VECTOR.bobPri, &(bobPri->key.curve25519Prv.len));
GOTO_ERR_IF_TRUE(bobPri->key.curve25519Prv.data == NULL, CRYPT_CMVP_COMMON_ERR);
bobPub->id = CRYPT_PKEY_X25519;
bobPub->key.curve25519Pub.data = CMVP_StringsToBins(X25519_VECTOR.bobPub, &(bobPub->key.curve25519Pub.len));
GOTO_ERR_IF_TRUE(bobPub->key.curve25519Pub.data == NULL, CRYPT_CMVP_COMMON_ERR);
return true;
ERR:
return false;
}
static bool CRYPT_CMVP_SelftestX25519Internal(void *libCtx, const char *attrName)
{
bool ret = false;
CRYPT_Data expShare = { NULL, 0 };
CRYPT_Data share1 = { NULL, 0 };
CRYPT_Data share2 = { NULL, 0 };
CRYPT_EAL_PkeyCtx *alice = NULL;
CRYPT_EAL_PkeyCtx *bob = NULL;
CRYPT_EAL_PkeyPrv alicePri = {0};
alicePri.key.curve25519Prv.data = NULL;
CRYPT_EAL_PkeyPub alicePub;
alicePub.key.curve25519Pub.data = NULL;
CRYPT_EAL_PkeyPrv bobPri = {0};
bobPri.key.curve25519Prv.data = NULL;
CRYPT_EAL_PkeyPub bobPub;
bobPub.key.curve25519Pub.data = NULL;
alice = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_X25519, 0, attrName);
GOTO_ERR_IF_TRUE(alice == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
bob = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_X25519, 0, attrName);
GOTO_ERR_IF_TRUE(bob == NULL, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(GetKey(&alicePri, &alicePub, &bobPri, &bobPub) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(GetData(&expShare, &share1, &share2) != true, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(alice, &alicePri) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(bob, &bobPub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyComputeShareKey(alice, bob, share1.data, &(share1.len)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(share1.len != expShare.len, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(share1.data, expShare.data, expShare.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPrv(bob, &bobPri) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeySetPub(alice, &alicePub) != CRYPT_SUCCESS, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(CRYPT_EAL_PkeyComputeShareKey(bob, alice, share2.data, &(share2.len)) != CRYPT_SUCCESS,
CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(share2.len != expShare.len, CRYPT_CMVP_ERR_ALGO_SELFTEST);
GOTO_ERR_IF_TRUE(memcmp(share2.data, expShare.data, expShare.len) != 0, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = true;
ERR:
BSL_SAL_Free(alicePri.key.curve25519Prv.data);
BSL_SAL_Free(alicePub.key.curve25519Pub.data);
BSL_SAL_Free(bobPri.key.curve25519Prv.data);
BSL_SAL_Free(bobPub.key.curve25519Pub.data);
BSL_SAL_Free(expShare.data);
BSL_SAL_Free(share1.data);
BSL_SAL_Free(share2.data);
CRYPT_EAL_PkeyFreeCtx(alice);
CRYPT_EAL_PkeyFreeCtx(bob);
return ret;
}
bool CRYPT_CMVP_SelftestX25519(void)
{
return CRYPT_CMVP_SelftestX25519Internal(NULL, NULL);
}
bool CRYPT_CMVP_SelftestProviderX25519(void *libCtx, const char *attrName)
{
return CRYPT_CMVP_SelftestX25519Internal(libCtx, attrName);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 || HITLS_CRYPTO_CMVP_FIPS */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/cmvp_selftest_x25519.c | C | unknown | 6,185 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CRYPT_CMVP_H
#define CRYPT_CMVP_H
#include "hitls_build.h"
#include <stdint.h>
#include "bsl_params.h"
#include "crypt_types.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_rand.h"
#include "crypt_eal_md.h"
#include "crypt_eal_mac.h"
#include "crypt_eal_cipher.h"
#include "crypt_eal_kdf.h"
#include "crypt_cmvp.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
typedef void* (*CmvpProvNewCtx)(void *provCtx);
typedef const char* (*CmvpGetVersion)(void *ctx);
typedef int32_t (*CmvpSelftest)(void *ctx, const BSL_Param *param);
typedef void (*CmvpFreeCtx)(void *ctx);
typedef struct {
CmvpProvNewCtx provNewCtx;
CmvpGetVersion getVersion;
CmvpSelftest selftest;
CmvpFreeCtx freeCtx;
} EAL_CmvpSelftestMethod;
struct EAL_SelftestCtx {
bool isProvider;
EAL_CmvpSelftestMethod *method;
void *data;
uint32_t state;
int32_t id;
};
typedef struct {
CRYPT_MAC_AlgId macId; /**< MAC algorithm ID */
uint32_t saltLen; /**< Salt length in bytes */
uint32_t iter;
uint32_t dkeyLen; /**< Derived key length in bytes */
} CRYPT_EAL_Pbkdf2Param;
typedef struct {
CRYPT_MAC_AlgId macId; /**< MAC algorithm ID */
uint32_t keyLen; /**< Derived key length in bytes */
} CRYPT_EAL_HkdfParam;
typedef struct {
CRYPT_EAL_Pbkdf2Param *pbkdf2;
CRYPT_EAL_HkdfParam *hkdf;
} CRYPT_EAL_KdfC2Data;
typedef struct {
const CRYPT_EAL_PkeyPara *para;
const CRYPT_EAL_PkeyPub *pub;
const CRYPT_EAL_PkeyPrv *prv;
CRYPT_MD_AlgId mdId; /**< MD algorithm ID */
CRYPT_PKEY_ParaId paraId; /**< PKEY parameter ID */
CRYPT_EVENT_TYPE oper;
const CRYPT_RSA_PkcsV15Para *pkcsv15;
BSL_Param *pss;
BSL_Param *oaep;
} CRYPT_EAL_PkeyC2Data;
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* CRYPT_CMVP_H */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/cmvp_utils/crypt_cmvp.h | C | unknown | 2,346 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_FIPS
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/fips_prov/cmvp_fips.c | C | unknown | 631 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CMVP_FIPS_H
#define CMVP_FIPS_H
#endif | 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/fips_prov/cmvp_fips.h | C | unknown | 591 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "cmvp_iso19790.h"
#include "cmvp_common.h"
#include "crypt_errno.h"
#include "crypt_cmvp_selftest.h"
#include "bsl_err_internal.h"
#include "crypt_utils.h"
#include "cmvp_integrity_hmac.h"
#include "crypt_params_key.h"
#include "securec.h"
#include "bsl_sal.h"
void CMVP_Iso19790EventProcess(CRYPT_EVENT_TYPE oper, CRYPT_ALGO_TYPE type, int32_t id, int32_t err)
{
if (oper == CRYPT_EVENT_RANDGEN) {
CMVP_WriteSyslog("openHiTLS", err == CRYPT_SUCCESS ? LOG_INFO : LOG_ERR,
"Excute - entropy collection, result: 0x%x", err);
return;
}
if (oper == CRYPT_EVENT_INTEGRITY_TEST) {
if (err == CRYPT_SUCCESS) {
CMVP_WriteSyslog("openHiTLS", LOG_INFO, "Integrity test begin.");
} else {
CMVP_WriteSyslog("openHiTLS", LOG_ERR, "Integrity test failed, errcode: 0x%x", err);
}
return;
}
// ISO/IEC 19790:2012 AS09.33
// The module shall provide an output status indication when zeroing is complete
if (oper == CRYPT_EVENT_ZERO && err == CRYPT_SUCCESS) {
CMVP_WriteSyslog("openHiTLS", LOG_INFO, "SSP already zeroisation - algorithm type: %d, id: %d", type, id);
}
/*
ISO/IEC 19790:2012 AS06.26
The following events of the cryptographic module should be recorded by the OS audit mechanism:
● Attempted to provide invalid input for the cryptographic officer function;
*/
if (err != CRYPT_SUCCESS) {
CMVP_WriteSyslog("openHiTLS", LOG_ERR, "Occur error - algorithm type: %d, id: %d, operate: %d, errcode: 0x%x",
type, id, oper, err);
}
/*
ISO/IEC 19790:2012 AS06.26
The following events of the cryptographic module should be recorded by the OS audit mechanism:
● Modify, access, delete, and add encrypted data and SSPs；
● Use security-related encryption features
ISO/IEC 19790:2012 AS02.24
When a service uses approved encryption algorithms, security functions or processes,
and specified services or processes in an approved manner,
the service shall provide corresponding status indications.
*/
CMVP_WriteSyslog("openHiTLS", LOG_INFO, "Excute - algorithm type: %d, id: %d, operate: %d", type, id, oper);
}
typedef struct {
uint32_t algId;
uint32_t mdId;
bool signValid;
bool verifyValid;
} ASYM_MD_MAP;
static const ASYM_MD_MAP ASYM_MD_LIST[] = {
{ CRYPT_PKEY_DSA, CRYPT_MD_SHA1, false, true },
{ CRYPT_PKEY_DSA, CRYPT_MD_SHA224, true, true },
{ CRYPT_PKEY_DSA, CRYPT_MD_SHA256, true, true },
{ CRYPT_PKEY_DSA, CRYPT_MD_SHA384, true, true },
{ CRYPT_PKEY_DSA, CRYPT_MD_SHA512, true, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA1, false, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA224, true, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA256, true, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA384, true, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA512, true, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA3_224, true, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA3_256, true, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA3_384, true, true },
{ CRYPT_PKEY_ECDSA, CRYPT_MD_SHA3_512, true, true },
{ CRYPT_PKEY_RSA, CRYPT_MD_SHA1, false, true },
{ CRYPT_PKEY_RSA, CRYPT_MD_SHA224, true, true },
{ CRYPT_PKEY_RSA, CRYPT_MD_SHA256, true, true },
{ CRYPT_PKEY_RSA, CRYPT_MD_SHA384, true, true },
{ CRYPT_PKEY_RSA, CRYPT_MD_SHA512, true, true },
{ CRYPT_PKEY_SM2, CRYPT_MD_SM3, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHA224, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHA256, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHA384, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHA512, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHA3_224, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHA3_256, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHA3_384, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHA3_512, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHAKE128, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_SHAKE256, true, true },
{ CRYPT_PKEY_SLH_DSA, CRYPT_MD_MAX, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHA224, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHA256, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHA384, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHA512, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHA3_224, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHA3_256, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHA3_384, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHA3_512, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHAKE128, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_SHAKE256, true, true },
{ CRYPT_PKEY_ML_DSA, CRYPT_MD_MAX, true, true },
};
static bool GetVaildFlag(uint32_t algId, uint32_t mdId, bool isSign)
{
if (algId == CRYPT_PKEY_ED25519) {
return true;
}
for (uint32_t i = 0; i < sizeof(ASYM_MD_LIST) / sizeof(ASYM_MD_LIST[0]); i++) {
if (isSign == true && algId == ASYM_MD_LIST[i].algId && mdId == ASYM_MD_LIST[i].mdId) {
return ASYM_MD_LIST[i].signValid;
} else if (isSign == false && algId == ASYM_MD_LIST[i].algId && mdId == ASYM_MD_LIST[i].mdId) {
return ASYM_MD_LIST[i].verifyValid;
}
}
return false;
}
// Check whether the RSA parameter is approved.
static bool RsaParamCheck(const CRYPT_EAL_PkeyC2Data *data)
{
if (data->para != NULL) {
CRYPT_RsaPara para = data->para->para.rsaPara;
// The length of the RSA key must be at least 2048 bits.
GOTO_ERR_IF_TRUE(para.bits < 2048, CRYPT_CMVP_ERR_PARAM_CHECK);
return true;
}
if (data->pub != NULL) {
CRYPT_RsaPub pub = data->pub->key.rsaPub;
// The length of the RSA key must be at least 2048 bits. 8 bits are 1 byte.
GOTO_ERR_IF_TRUE(pub.nLen < (2048 / 8), CRYPT_CMVP_ERR_PARAM_CHECK);
return true;
}
if (data->prv != NULL) {
CRYPT_RsaPrv prv = data->prv->key.rsaPrv;
// The length of the RSA key must be at least 2048 bits. 8 bits are 1 byte.
GOTO_ERR_IF_TRUE(prv.nLen < (2048 / 8), CRYPT_CMVP_ERR_PARAM_CHECK);
return true;
}
if (data->pkcsv15 != NULL) {
GOTO_ERR_IF_TRUE(
(GetVaildFlag(CRYPT_PKEY_RSA, data->pkcsv15->mdId, false) == false), CRYPT_CMVP_ERR_PARAM_CHECK);
return true;
}
if (data->pss != NULL) {
BSL_Param *mdParam = BSL_PARAM_FindParam(data->pss, CRYPT_PARAM_RSA_MD_ID);
GOTO_ERR_IF_TRUE(mdParam == NULL, CRYPT_CMVP_ERR_PARAM_CHECK);
BSL_Param *mgfParam = BSL_PARAM_FindParam(data->pss, CRYPT_PARAM_RSA_MGF1_ID);
GOTO_ERR_IF_TRUE(mgfParam == NULL, CRYPT_CMVP_ERR_PARAM_CHECK);
GOTO_ERR_IF_TRUE((GetVaildFlag(CRYPT_PKEY_RSA, *(uint32_t *)(mdParam->value), false) == false),
CRYPT_CMVP_ERR_PARAM_CHECK);
GOTO_ERR_IF_TRUE((GetVaildFlag(CRYPT_PKEY_RSA, *(uint32_t *)(mgfParam->value), false) == false),
CRYPT_CMVP_ERR_PARAM_CHECK);
return true;
}
if (data->oaep != NULL) {
BSL_Param *mdParam = BSL_PARAM_FindParam(data->oaep, CRYPT_PARAM_RSA_MD_ID);
GOTO_ERR_IF_TRUE(mdParam == NULL, CRYPT_CMVP_ERR_PARAM_CHECK);
BSL_Param *mgfParam = BSL_PARAM_FindParam(data->oaep, CRYPT_PARAM_RSA_MGF1_ID);
GOTO_ERR_IF_TRUE(mgfParam == NULL, CRYPT_CMVP_ERR_PARAM_CHECK);
GOTO_ERR_IF_TRUE((GetVaildFlag(CRYPT_PKEY_RSA, *(uint32_t *)(mdParam->value), false) == false),
CRYPT_CMVP_ERR_PARAM_CHECK);
GOTO_ERR_IF_TRUE((GetVaildFlag(CRYPT_PKEY_RSA, *(uint32_t *)(mgfParam->value), false) == false),
CRYPT_CMVP_ERR_PARAM_CHECK);
return true;
}
return true;
ERR:
return false;
}
// Check whether the DSA parameter is approved
static bool DsaParamCheck(const CRYPT_EAL_PkeyC2Data *data)
{
if (data->para == NULL) {
return true;
}
uint32_t pLen = data->para->para.dsaPara.pLen;
uint32_t qLen = data->para->para.dsaPara.qLen;
// https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar2.pdf Chapter 3
// (L, N) = (2048, 224)，(2048, 256), 8 bits: 1 byte
if ((pLen != 2048 / 8 || qLen != 224 / 8) && (pLen != 2048 / 8 || qLen != 256 / 8) &&
// (L, N) = (3072, 256), 8 bits: 1 byte
(pLen != 3072 / 8 || qLen != 256 / 8)) {
return false;
}
return true;
}
// Check whether the dh parameter is approved
static bool DhParamCheck(const CRYPT_EAL_PkeyC2Data *data)
{
static const uint32_t list[] = {
CRYPT_DH_RFC2409_768,
CRYPT_DH_RFC2409_1024,
CRYPT_DH_RFC3526_1536,
};
if (data->para != NULL) {
uint32_t pLen = data->para->para.dhPara.pLen;
uint32_t qLen = data->para->para.dhPara.qLen;
// https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar2.pdf Chapter 5
// (len(p), len(q)) = (2048, 224)
// The length of p must be at least 2048 bits, and the length of q must be at least 224 bits.
GOTO_ERR_IF_TRUE(((pLen != 2048 / 8 || qLen != 224 / 8) &&
// (len(p), len(q)) = (2048, 256)
(pLen != 2048 / 8 || qLen != 256 / 8)), CRYPT_CMVP_ERR_PARAM_CHECK);
}
if (data->paraId != CRYPT_PKEY_PARAID_MAX) {
// The length of p must be at least 2048 bits, and the length of q must be at least 224 bits.
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
GOTO_ERR_IF_TRUE((data->paraId == list[i]), CRYPT_CMVP_ERR_PARAM_CHECK);
}
}
return true;
ERR:
return false;
}
static bool EcdhParamCheck(const CRYPT_EAL_PkeyC2Data *data)
{
// https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar2.pdf Chapters 3 and 5
// Requires curve specified using SP 800-56A
static const uint32_t list[] = {
CRYPT_ECC_NISTP224,
CRYPT_ECC_NISTP256,
CRYPT_ECC_NISTP384,
CRYPT_ECC_NISTP521,
CRYPT_ECC_SM2,
CRYPT_PKEY_PARAID_MAX,
};
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
if (data->paraId == list[i]) {
return true;
}
}
return false;
}
static bool EcdsaParamCheck(const CRYPT_EAL_PkeyC2Data *data)
{
// https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar2.pdf Chapters 3 and 5
// Requires curve specified using SP 800-56A
static const uint32_t list[] = {
CRYPT_ECC_NISTP224,
CRYPT_ECC_NISTP256,
CRYPT_ECC_NISTP384,
CRYPT_ECC_NISTP521,
CRYPT_ECC_BRAINPOOLP256R1,
CRYPT_ECC_BRAINPOOLP384R1,
CRYPT_ECC_BRAINPOOLP512R1,
CRYPT_PKEY_PARAID_MAX,
};
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
if (data->paraId == list[i]) {
return true;
}
}
return false;
}
static bool ISO19790_AsymParamCheck(CRYPT_PKEY_AlgId id, const CRYPT_EAL_PkeyC2Data *data)
{
// If the value is NULL, the interface does not need to check the algorithm parameters
// and directly returns a success message.
if (data == NULL) {
return true;
}
switch (id) {
case CRYPT_PKEY_DSA:
GOTO_ERR_IF_TRUE(DsaParamCheck(data) != true, CRYPT_CMVP_ERR_PARAM_CHECK);
break;
case CRYPT_PKEY_RSA:
GOTO_ERR_IF_TRUE(RsaParamCheck(data) != true, CRYPT_CMVP_ERR_PARAM_CHECK);
break;
case CRYPT_PKEY_DH:
GOTO_ERR_IF_TRUE(DhParamCheck(data) != true, CRYPT_CMVP_ERR_PARAM_CHECK);
break;
case CRYPT_PKEY_ECDH:
GOTO_ERR_IF_TRUE(EcdhParamCheck(data) != true, CRYPT_CMVP_ERR_PARAM_CHECK);
break;
case CRYPT_PKEY_ECDSA:
GOTO_ERR_IF_TRUE(EcdsaParamCheck(data) != true, CRYPT_CMVP_ERR_PARAM_CHECK);
break;
default:
break;
}
if (data->oper == CRYPT_EVENT_SIGN) {
GOTO_ERR_IF_TRUE((GetVaildFlag(id, data->mdId, true) == false), CRYPT_CMVP_ERR_PARAM_CHECK);
return true;
}
if (data->oper == CRYPT_EVENT_VERIFY) {
GOTO_ERR_IF_TRUE((GetVaildFlag(id, data->mdId, false) == false), CRYPT_CMVP_ERR_PARAM_CHECK);
return true;
}
return true;
ERR:
return false;
}
static bool ISO19790_MacParamCheck(CRYPT_MAC_AlgId id, uint32_t keyLen)
{
(void)id;
// https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar2.pdf Chapter 10
// Key lengths ≥ 112 bits, 8 bits: 1 byte
if (keyLen >= (112 / 8)) {
return true;
}
return false;
}
static bool ISO19790_KdfTls12ParamCheck(CRYPT_MAC_AlgId id, uint32_t keyLen)
{
static const uint32_t list[] = {
CRYPT_MAC_HMAC_SHA256,
CRYPT_MAC_HMAC_SHA384,
CRYPT_MAC_HMAC_SHA512,
};
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
// https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar2.pdf Chapter 8
// Key lengths ≥ 112 bits, 8 bits: 1 byte
if (id == list[i] && (keyLen >= (112 / 8))) {
return true;
}
}
return false;
}
static bool ISO19790_HkdfParamCheck(CRYPT_MAC_AlgId id, uint32_t keyLen)
{
static const uint32_t list[] = {
CRYPT_MAC_HMAC_SHA1,
CRYPT_MAC_HMAC_SHA224,
CRYPT_MAC_HMAC_SHA256,
CRYPT_MAC_HMAC_SHA384,
CRYPT_MAC_HMAC_SHA512
};
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
// https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar2.pdf Chapter 8
// Key lengths ≥ 112 bits, 8 bits: 1 byte
if (id == list[i] && (keyLen >= (112 / 8))) {
return true;
}
}
return false;
}
static bool ISO19790_PbkdfParamCheck(const CRYPT_EAL_Pbkdf2Param *param)
{
static const uint32_t list[] = {
CRYPT_MAC_HMAC_SHA1,
CRYPT_MAC_HMAC_SHA224,
CRYPT_MAC_HMAC_SHA256,
CRYPT_MAC_HMAC_SHA384,
CRYPT_MAC_HMAC_SHA512,
CRYPT_MAC_HMAC_SM3,
CRYPT_MAC_HMAC_SHA3_224,
CRYPT_MAC_HMAC_SHA3_256,
CRYPT_MAC_HMAC_SHA3_384,
CRYPT_MAC_HMAC_SHA3_512
};
bool ret = false;
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
if (param->macId == list[i]) {
ret = true;
break;
}
}
if (!ret) {
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
return false;
}
if (param->saltLen < 16) { // FIPS SP800-132 section 5,The salt value must contain at least 16 bytes.
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
return false;
}
if (param->iter < 1000) { // FIPS SP800-132 section 5,The number of iterations must be at least 1000.
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
return false;
}
if (param->dkeyLen < 14) { // FIPS SP800-132 section 5,The length of the derived key must be at least 14 bytes.
BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
return false;
}
return true;
}
static bool ISO19790_CipherKat(void *libCtx, const char *attrName)
{
static const uint32_t list[] = {
CRYPT_CIPHER_AES128_ECB, CRYPT_CIPHER_AES192_ECB, CRYPT_CIPHER_AES256_ECB,
CRYPT_CIPHER_AES128_CBC, CRYPT_CIPHER_AES192_CBC, CRYPT_CIPHER_AES256_CBC,
CRYPT_CIPHER_AES128_CTR, CRYPT_CIPHER_AES192_CTR, CRYPT_CIPHER_AES256_CTR,
CRYPT_CIPHER_AES128_CCM, CRYPT_CIPHER_AES192_CCM, CRYPT_CIPHER_AES256_CCM,
CRYPT_CIPHER_AES128_GCM, CRYPT_CIPHER_AES192_GCM, CRYPT_CIPHER_AES256_GCM,
CRYPT_CIPHER_AES128_XTS, CRYPT_CIPHER_AES256_XTS,
CRYPT_CIPHER_AES128_OFB, CRYPT_CIPHER_AES192_OFB, CRYPT_CIPHER_AES256_OFB,
CRYPT_CIPHER_AES128_CFB, CRYPT_CIPHER_AES192_CFB, CRYPT_CIPHER_AES256_CFB,
CRYPT_CIPHER_CHACHA20_POLY1305,
CRYPT_CIPHER_SM4_XTS, CRYPT_CIPHER_SM4_CBC, CRYPT_CIPHER_SM4_ECB,
CRYPT_CIPHER_SM4_CTR, CRYPT_CIPHER_SM4_GCM, CRYPT_CIPHER_SM4_CFB,
CRYPT_CIPHER_SM4_OFB,
};
bool ret = false;
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
if (list[i] == CRYPT_CIPHER_CHACHA20_POLY1305) {
ret = CRYPT_CMVP_SelftestProviderChacha20poly1305(libCtx, attrName);
} else {
ret = CRYPT_CMVP_SelftestProviderCipher(libCtx, attrName, list[i]);
}
if (!ret) {
return false;
}
}
return true;
}
static bool ISO19790_MdKat(void *libCtx, const char *attrName)
{
static const uint32_t list[] = {
CRYPT_MD_SHA1,
CRYPT_MD_SHA224, CRYPT_MD_SHA256, CRYPT_MD_SHA384, CRYPT_MD_SHA512,
CRYPT_MD_SHA3_224, CRYPT_MD_SHA3_256, CRYPT_MD_SHA3_384, CRYPT_MD_SHA3_512,
CRYPT_MD_SHAKE128, CRYPT_MD_SHAKE256, CRYPT_MD_SM3,
};
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
if (!CRYPT_CMVP_SelftestProviderMd(libCtx, attrName, list[i])) {
return false;
}
}
return true;
}
static bool ISO19790_MacKat(void *libCtx, const char *attrName)
{
static const uint32_t list[] = {
CRYPT_MAC_CMAC_AES128, CRYPT_MAC_CMAC_AES192, CRYPT_MAC_CMAC_AES256,
CRYPT_MAC_GMAC_AES128, CRYPT_MAC_GMAC_AES192, CRYPT_MAC_GMAC_AES256,
CRYPT_MAC_HMAC_SHA1, CRYPT_MAC_HMAC_SHA224, CRYPT_MAC_HMAC_SHA256, CRYPT_MAC_HMAC_SHA384, CRYPT_MAC_HMAC_SHA512,
CRYPT_MAC_HMAC_SM3,
CRYPT_MAC_CMAC_SM4,
};
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
if (!CRYPT_CMVP_SelftestProviderMac(libCtx, attrName, list[i])) {
return false;
}
}
return true;
}
static bool ISO19790_DrbgKat(void *libCtx, const char *attrName)
{
static const uint32_t list[] = {
CRYPT_RAND_AES128_CTR, CRYPT_RAND_AES192_CTR, CRYPT_RAND_AES256_CTR,
CRYPT_RAND_AES128_CTR_DF, CRYPT_RAND_AES192_CTR_DF, CRYPT_RAND_AES256_CTR_DF,
CRYPT_RAND_HMAC_SHA1,
CRYPT_RAND_HMAC_SHA224, CRYPT_RAND_HMAC_SHA256, CRYPT_RAND_HMAC_SHA384, CRYPT_RAND_HMAC_SHA512,
CRYPT_RAND_SHA1, CRYPT_RAND_SHA224, CRYPT_RAND_SHA256, CRYPT_RAND_SHA384, CRYPT_RAND_SHA512,
CRYPT_RAND_SM4_CTR_DF,
CRYPT_RAND_SM3,
};
for (uint32_t i = 0; i < sizeof(list) / sizeof(list[0]); i++) {
if (!CRYPT_CMVP_SelftestProviderDrbg(libCtx, attrName, list[i])) {
return false;
}
}
return true;
}
static bool ISO19790_KdfKat(void *libCtx, const char *attrName)
{
if (!CRYPT_CMVP_SelftestProviderKdfTls12(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderHkdf(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderScrypt(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderPbkdf2(libCtx, attrName, CRYPT_MAC_HMAC_SHA1)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderPbkdf2(libCtx, attrName, CRYPT_MAC_HMAC_SM3)) {
return false;
}
return true;
}
static bool ISO19790_PkeyKat(void *libCtx, const char *attrName)
{
if (!CRYPT_CMVP_SelftestProviderDsa(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderEcdsa(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderRsa(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderEd25519(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderSM2(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderEcdh(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderDh(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderX25519(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderMlkemEncapsDecaps(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderMldsaSignVerify(libCtx, attrName)) {
return false;
}
if (!CRYPT_CMVP_SelftestProviderSlhdsaSignVerify(libCtx, attrName)) {
return false;
}
return true;
}
bool CMVP_Iso19790PkeyPct(CRYPT_Iso_Pkey_Ctx *ctx)
{
return CRYPT_CMVP_SelftestPkeyPct(ctx->ctx, ctx->algId);
}
bool CMVP_Iso19790PkeyC2(CRYPT_PKEY_AlgId id, const CRYPT_EAL_PkeyC2Data *data)
{
return ISO19790_AsymParamCheck(id, data);
}
bool CMVP_Iso19790MacC2(CRYPT_MAC_AlgId id, uint32_t keyLen)
{
return ISO19790_MacParamCheck(id, keyLen);
}
bool CMVP_Iso19790KdfC2(CRYPT_KDF_AlgId id, const CRYPT_EAL_KdfC2Data *data)
{
switch (id) {
case CRYPT_KDF_SCRYPT:
return false;
case CRYPT_KDF_PBKDF2:
return ISO19790_PbkdfParamCheck(data->pbkdf2);
case CRYPT_KDF_KDFTLS12:
return ISO19790_KdfTls12ParamCheck(data->hkdf->macId, data->hkdf->keyLen);
case CRYPT_KDF_HKDF:
return ISO19790_HkdfParamCheck(data->hkdf->macId, data->hkdf->keyLen);
default:
return false;
}
}
int32_t CMVP_Iso19790Kat(void *libCtx, const char *attrName)
{
bool ret = false;
ret = ISO19790_CipherKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = ISO19790_MdKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = ISO19790_MacKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = ISO19790_DrbgKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = ISO19790_KdfKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
ret = ISO19790_PkeyKat(libCtx, attrName);
RETURN_RET_IF(ret == false, CRYPT_CMVP_ERR_ALGO_SELFTEST);
return CRYPT_SUCCESS;
}
int32_t CMVP_Iso19790CheckIntegrity(void *libCtx, const char *attrName)
{
return CMVP_CheckIntegrity(libCtx, attrName, CRYPT_MAC_HMAC_SHA256);
}
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/iso_prov/cmvp_iso19790.c | C | unknown | 22,558 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#ifndef CMVP_ISO19790_H
#define CMVP_ISO19790_H
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include <stdint.h>
#include <stdbool.h>
#include "crypt_cmvp.h"
#include "crypt_algid.h"
#include "crypt_iso_provderimpl.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
void CMVP_Iso19790EventProcess(CRYPT_EVENT_TYPE oper, CRYPT_ALGO_TYPE type, int32_t id, int32_t err);
bool CMVP_Iso19790PkeyC2(CRYPT_PKEY_AlgId id, const CRYPT_EAL_PkeyC2Data *data);
bool CMVP_Iso19790MacC2(CRYPT_MAC_AlgId id, uint32_t keyLen);
bool CMVP_Iso19790KdfC2(CRYPT_KDF_AlgId id, const CRYPT_EAL_KdfC2Data *data);
int32_t CMVP_Iso19790Kat(void *libCtx, const char *attrName);
int32_t CMVP_Iso19790CheckIntegrity(void *libCtx, const char *attrName);
bool CMVP_Iso19790PkeyPct(CRYPT_Iso_Pkey_Ctx *ctx);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */
#endif /* CMVP_ISO19790_H */
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/iso_prov/cmvp_iso19790.h | C | unknown | 1,470 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#include "crypt_modes_cbc.h"
#include "crypt_modes_ccm.h"
#include "crypt_modes_chacha20poly1305.h"
#include "crypt_modes_ctr.h"
#include "crypt_modes_ecb.h"
#include "crypt_modes_gcm.h"
#include "crypt_modes_ofb.h"
#include "crypt_modes_cfb.h"
#include "crypt_modes_xts.h"
#include "crypt_local_types.h"
#include "crypt_errno.h"
#include "bsl_err_internal.h"
#include "crypt_ealinit.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provider.h"
typedef struct {
int32_t algId;
void *ctx;
void *provCtx;
} IsoCipherCtx;
static int32_t CRYPT_ASMCAP_CipherCheck(int32_t algId)
{
#ifdef HITLS_CRYPTO_ASM_CHECK
if (CRYPT_ASMCAP_Cipher(algId) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
}
#else
(void)algId;
#endif
return CRYPT_SUCCESS;
}
#define CIPHER_NewCtx_FUNC(name) \
static void *MODES_##name##_NewCtxWrapper(CRYPT_EAL_IsoProvCtx *provCtx, int32_t algId) \
{ \
if (CRYPT_ASMCAP_CipherCheck(algId) != CRYPT_SUCCESS) { \
return NULL; \
} \
if (provCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return NULL; \
} \
void *cipherCtx = MODES_##name##_NewCtx(algId); \
if (cipherCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
IsoCipherCtx *ctx = BSL_SAL_Calloc(1, sizeof(IsoCipherCtx)); \
if (ctx == NULL) { \
MODES_##name##_FreeCtx(cipherCtx); \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
ctx->algId = algId; \
ctx->ctx = cipherCtx; \
ctx->provCtx = provCtx; \
return ctx; \
} \
\
static int32_t MODES_##name##_CtrlWrapper(IsoCipherCtx *ctx, int32_t cmd, void *val, uint32_t valLen) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return MODES_##name##_Ctrl(ctx->ctx, cmd, val, valLen); \
} \
\
static void MODES_##name##_FreeCtxWrapper(IsoCipherCtx *ctx) \
{ \
if (ctx == NULL) { \
return; \
} \
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ZERO, CRYPT_ALGO_CIPHER, ctx->algId); \
if (ctx->ctx != NULL) { \
MODES_##name##_FreeCtx(ctx->ctx); \
} \
BSL_SAL_Free(ctx); \
}
#define CIPHER_INIT_FUNC(initFunc, updateFunc, finalFunc, deinitFunc) \
static int32_t initFunc##Wrapper(IsoCipherCtx *ctx, const uint8_t *key, uint32_t keyLen, \
const uint8_t *iv, uint32_t ivLen, void *param, bool enc) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t event = enc ? CRYPT_EVENT_ENC : CRYPT_EVENT_DEC; \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, event, CRYPT_ALGO_CIPHER, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_SETSSP, CRYPT_ALGO_CIPHER, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return (initFunc)(ctx->ctx, key, keyLen, iv, ivLen, param, enc); \
} \
\
static int32_t updateFunc##Wrapper(IsoCipherCtx *ctx, const uint8_t *in, uint32_t inLen, \
uint8_t *out, uint32_t *outLen) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return (updateFunc)(ctx->ctx, in, inLen, out, outLen); \
} \
\
static int32_t finalFunc##Wrapper(IsoCipherCtx *ctx, uint8_t *out, uint32_t *outLen) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return (finalFunc)(ctx->ctx, out, outLen); \
} \
\
static int32_t deinitFunc##Wrapper(IsoCipherCtx *ctx) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ZERO, CRYPT_ALGO_CIPHER, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return (deinitFunc)(ctx->ctx); \
} \
CIPHER_NewCtx_FUNC(CBC)
CIPHER_NewCtx_FUNC(CCM)
CIPHER_NewCtx_FUNC(CFB)
CIPHER_NewCtx_FUNC(CTR)
CIPHER_NewCtx_FUNC(ECB)
CIPHER_NewCtx_FUNC(GCM)
CIPHER_NewCtx_FUNC(OFB)
CIPHER_NewCtx_FUNC(XTS)
CIPHER_NewCtx_FUNC(CHACHA20POLY1305)
CIPHER_INIT_FUNC(MODES_CBC_InitCtxEx, MODES_CBC_UpdateEx, MODES_CBC_FinalEx, MODES_CBC_DeInitCtx)
CIPHER_INIT_FUNC(MODES_CCM_InitCtx, MODES_CCM_UpdateEx, MODES_CCM_Final, MODES_CCM_DeInitCtx)
CIPHER_INIT_FUNC(MODES_CFB_InitCtxEx, MODES_CFB_UpdateEx, MODES_CFB_Final, MODES_CFB_DeInitCtx)
CIPHER_INIT_FUNC(MODES_CTR_InitCtxEx, MODES_CTR_UpdateEx, MODES_CTR_Final, MODES_CTR_DeInitCtx)
CIPHER_INIT_FUNC(MODES_ECB_InitCtxEx, MODES_ECB_UpdateEx, MODES_ECB_Final, MODES_ECB_DeinitCtx)
CIPHER_INIT_FUNC(MODES_GCM_InitCtxEx, MODES_GCM_UpdateEx, MODES_GCM_Final, MODES_GCM_DeInitCtx)
CIPHER_INIT_FUNC(MODES_OFB_InitCtxEx, MODES_OFB_UpdateEx, MODES_OFB_Final, MODES_OFB_DeInitCtx)
CIPHER_INIT_FUNC(MODES_XTS_InitCtxEx, MODES_XTS_UpdateEx, MODES_XTS_Final, MODES_XTS_DeInitCtx)
CIPHER_INIT_FUNC(MODES_CHACHA20POLY1305_InitCtx, MODES_CHACHA20POLY1305_Update, MODES_CHACHA20POLY1305_Final,
MODES_CHACHA20POLY1305_DeInitCtx)
const CRYPT_EAL_Func g_isoCbc[] = {
#ifdef HITLS_CRYPTO_CBC
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_CBC_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CBC_InitCtxExWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_CBC_UpdateExWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_CBC_FinalExWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CBC_DeInitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CBC_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CBC_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoCcm[] = {
#ifdef HITLS_CRYPTO_CCM
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_CCM_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CCM_InitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_CCM_UpdateExWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_CCM_FinalWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CCM_DeInitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CCM_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CCM_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoCfb[] = {
#ifdef HITLS_CRYPTO_CFB
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_CFB_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CFB_InitCtxExWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_CFB_UpdateExWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_CFB_FinalWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CFB_DeInitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CFB_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CFB_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoChaCha[] = {
#if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_CHACHA20POLY1305_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CHACHA20POLY1305_InitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_CHACHA20POLY1305_UpdateWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_CHACHA20POLY1305_FinalWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CHACHA20POLY1305_DeInitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CHACHA20POLY1305_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CHACHA20POLY1305_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoCtr[] = {
#ifdef HITLS_CRYPTO_CTR
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_CTR_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_CTR_InitCtxExWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_CTR_UpdateExWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_CTR_FinalWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_CTR_DeInitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_CTR_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_CTR_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoEcb[] = {
#ifdef HITLS_CRYPTO_ECB
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_ECB_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_ECB_InitCtxExWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_ECB_UpdateExWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_ECB_FinalWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_ECB_DeinitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_ECB_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_ECB_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoGcm[] = {
#ifdef HITLS_CRYPTO_GCM
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_GCM_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_GCM_InitCtxExWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_GCM_UpdateExWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_GCM_FinalWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_GCM_DeInitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_GCM_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_GCM_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoOfb[] = {
#ifdef HITLS_CRYPTO_OFB
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_OFB_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_OFB_InitCtxExWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_OFB_UpdateExWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_OFB_FinalWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_OFB_DeInitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_OFB_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_OFB_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoXts[] = {
#ifdef HITLS_CRYPTO_XTS
{CRYPT_EAL_IMPLCIPHER_NEWCTX, (CRYPT_EAL_ImplCipherNewCtx)MODES_XTS_NewCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_INITCTX, (CRYPT_EAL_ImplCipherInitCtx)MODES_XTS_InitCtxExWrapper},
{CRYPT_EAL_IMPLCIPHER_UPDATE, (CRYPT_EAL_ImplCipherUpdate)MODES_XTS_UpdateExWrapper},
{CRYPT_EAL_IMPLCIPHER_FINAL, (CRYPT_EAL_ImplCipherFinal)MODES_XTS_FinalWrapper},
{CRYPT_EAL_IMPLCIPHER_DEINITCTX, (CRYPT_EAL_ImplCipherDeinitCtx)MODES_XTS_DeInitCtxWrapper},
{CRYPT_EAL_IMPLCIPHER_CTRL, (CRYPT_EAL_ImplCipherCtrl)MODES_XTS_CtrlWrapper},
{CRYPT_EAL_IMPLCIPHER_FREECTX, (CRYPT_EAL_ImplCipherFreeCtx)MODES_XTS_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */ | 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/iso_prov/crypt_iso_cipher.c | C | unknown | 20,295 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "crypt_params_key.h"
#include "crypt_cmvp_selftest.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provider.h"
#define ISO_19790_PROVIDER_VERSION "openHiTLS ISO 19790 Provider Version : V0.3.0"
typedef struct {
void *ctx;
void *provCtx;
void *libCtx;
} IsoSelftestCtx;
static IsoSelftestCtx *CRYPT_Selftest_NewCtx(CRYPT_EAL_IsoProvCtx *provCtx)
{
if (provCtx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return NULL;
}
IsoSelftestCtx *ctx = (IsoSelftestCtx *)BSL_SAL_Calloc(1, sizeof(IsoSelftestCtx));
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL);
return NULL;
}
ctx->provCtx = provCtx;
ctx->libCtx = provCtx->libCtx;
return ctx;
}
static const char *CRYPT_Selftest_GetVersion(IsoSelftestCtx *ctx)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return NULL;
}
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_GET_VERSION, 0, 0);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return NULL;
}
return ISO_19790_PROVIDER_VERSION;
}
static int32_t CRYPT_Selftest_Selftest(IsoSelftestCtx *ctx, const BSL_Param *param)
{
int32_t type = 0;
uint32_t len = sizeof(type);
if (ctx == NULL || param == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
const BSL_Param *temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_CMVP_SELFTEST_TYPE);
if (temp == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
int32_t ret = BSL_PARAM_GetValue(temp, CRYPT_PARAM_CMVP_SELFTEST_TYPE, BSL_PARAM_TYPE_INT32, &type, &len);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
int32_t event = 0;
switch (type) {
case CRYPT_CMVP_INTEGRITY_TEST:
event = CRYPT_EVENT_INTEGRITY_TEST;
break;
case CRYPT_CMVP_KAT_TEST:
event = CRYPT_EVENT_KAT_TEST;
break;
default:
BSL_ERR_PUSH_ERROR(CRYPT_NOT_SUPPORT);
return CRYPT_NOT_SUPPORT;
}
BSL_Param tmpParams[3] = {{0}, {0}, BSL_PARAM_END};
(void)BSL_PARAM_InitValue(&tmpParams[0], CRYPT_PARAM_EVENT, BSL_PARAM_TYPE_INT32, &event, sizeof(event));
(void)BSL_PARAM_InitValue(&tmpParams[1], CRYPT_PARAM_LIB_CTX, BSL_PARAM_TYPE_CTX_PTR, ctx->libCtx, 0);
return CRYPT_Iso_EventOperation(ctx->provCtx, tmpParams);
}
static void CRYPT_Selftest_FreeCtx(IsoSelftestCtx *ctx)
{
if (ctx == NULL) {
return;
}
BSL_SAL_Free(ctx);
}
const CRYPT_EAL_Func g_isoSelftest[] = {
{CRYPT_EAL_IMPLSELFTEST_NEWCTX, (CRYPT_EAL_ImplSelftestNewCtx)CRYPT_Selftest_NewCtx},
{CRYPT_EAL_IMPLSELFTEST_GETVERSION, (CRYPT_EAL_ImplSelftestGetVersion)CRYPT_Selftest_GetVersion},
{CRYPT_EAL_IMPLSELFTEST_SELFTEST, (CRYPT_EAL_ImplSelftestSelftest)CRYPT_Selftest_Selftest},
{CRYPT_EAL_IMPLSELFTEST_FREECTX, (CRYPT_EAL_ImplSelftestFreeCtx)CRYPT_Selftest_FreeCtx},
CRYPT_EAL_FUNC_END
};
#endif // HITLS_CRYPTO_CMVP_ISO19790
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/iso_prov/crypt_iso_cmvp.c | C | unknown | 3,801 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#include "crypt_pbkdf2.h"
#include "crypt_kdf_tls12.h"
#include "crypt_hkdf.h"
#include "crypt_scrypt.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "bsl_err_internal.h"
#include "crypt_cmvp.h"
#include "cmvp_iso19790.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provider.h"
typedef struct {
int32_t algId;
void *ctx;
void *provCtx;
} IsoKdfCtx;
/* Constants for parameter validation */
#define KDF_DEF_MAC_ALGID CRYPT_MAC_HMAC_SHA256
#define KDF_DEF_SALT_LEN 16
#define KDF_DEF_PBKDF2_ITER 1024
#define KDF_DEF_KEY_LEN 16
static int32_t GetMacId(const BSL_Param *param, CRYPT_MAC_AlgId *macId)
{
int32_t id;
uint32_t len = sizeof(id);
const BSL_Param *temp = NULL;
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_KDF_MAC_ID)) == NULL) {
return CRYPT_SUCCESS;
}
int32_t ret = BSL_PARAM_GetValue(temp, CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &id, &len);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
*macId = (CRYPT_MAC_AlgId)id;
return CRYPT_SUCCESS;
}
static int32_t GetPbkdf2Params(const BSL_Param *param, CRYPT_EAL_Pbkdf2Param *pbkdf2Param)
{
uint32_t iter = 0;
uint32_t len = 0;
const BSL_Param *temp = NULL;
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_KDF_SALT)) != NULL) {
pbkdf2Param->saltLen = temp->valueLen;
}
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_KDF_ITER)) != NULL) {
len = sizeof(iter);
int32_t ret = BSL_PARAM_GetValue(temp, CRYPT_PARAM_KDF_ITER, BSL_PARAM_TYPE_UINT32, &iter, &len);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
pbkdf2Param->iter = iter;
}
return GetMacId(param, &pbkdf2Param->macId);
}
static int32_t GetHkdfAndTlskdfParam(const BSL_Param *param, CRYPT_EAL_HkdfParam *hkdf)
{
const BSL_Param *temp = NULL;
if ((temp = BSL_PARAM_FindConstParam(param, CRYPT_PARAM_KDF_KEY)) != NULL) {
hkdf->keyLen = temp->valueLen;
}
return GetMacId(param, &hkdf->macId);
}
static int32_t CheckKdfParam(IsoKdfCtx *ctx, const BSL_Param *param)
{
int32_t ret = CRYPT_SUCCESS;
CRYPT_EAL_Pbkdf2Param pbkdf2 = {KDF_DEF_MAC_ALGID, KDF_DEF_SALT_LEN, KDF_DEF_PBKDF2_ITER, KDF_DEF_KEY_LEN};
CRYPT_EAL_HkdfParam hkdf = {KDF_DEF_MAC_ALGID, KDF_DEF_KEY_LEN};
CRYPT_EAL_KdfC2Data data = {&pbkdf2, &hkdf};
switch (ctx->algId) {
case CRYPT_KDF_HKDF:
case CRYPT_KDF_KDFTLS12:
ret = GetHkdfAndTlskdfParam(param, &hkdf);
break;
case CRYPT_KDF_PBKDF2:
ret = GetPbkdf2Params(param, &pbkdf2);
break;
default:
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
if (ret != CRYPT_SUCCESS) {
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_KDF, ctx->algId);
return ret;
}
if (!CMVP_Iso19790KdfC2(ctx->algId, &data)) {
BSL_ERR_PUSH_ERROR(CRYPT_CMVP_ERR_PARAM_CHECK);
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_KDF, ctx->algId);
return CRYPT_CMVP_ERR_PARAM_CHECK;
}
return ret;
}
/* Algorithm-specific parameter check functions */
static int32_t SSPLog(IsoKdfCtx *ctx, const BSL_Param *param, const int32_t *sspParam, uint32_t paramCount)
{
for (uint32_t i = 0; i < paramCount; i++) {
if (BSL_PARAM_FindConstParam(param, sspParam[i]) != NULL) {
return CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_SETSSP, CRYPT_ALGO_KDF, ctx->algId);
}
}
return CRYPT_SUCCESS;
}
#ifdef HITLS_CRYPTO_SCRYPT
static int32_t CheckSCRYPTParamAndLog(IsoKdfCtx *ctx, const BSL_Param *param)
{
int32_t sspParam[] = {CRYPT_PARAM_KDF_PASSWORD};
return SSPLog(ctx, param, sspParam, sizeof(sspParam)/sizeof(sspParam[0]));
}
#endif
#ifdef HITLS_CRYPTO_KDFTLS12
static int32_t CheckKDFTLS12ParamAndLog(IsoKdfCtx *ctx, const BSL_Param *param)
{
int32_t ret = CheckKdfParam(ctx, param);
if (ret != CRYPT_SUCCESS) {
return ret;
}
int32_t sspParam[] = {CRYPT_PARAM_KDF_KEY, CRYPT_PARAM_KDF_SEED};
return SSPLog(ctx, param, sspParam, sizeof(sspParam)/sizeof(sspParam[0]));
}
#endif
#ifdef HITLS_CRYPTO_HKDF
static int32_t CheckHKDFParamAndLog(IsoKdfCtx *ctx, const BSL_Param *param)
{
int32_t ret = CheckKdfParam(ctx, param);
if (ret != CRYPT_SUCCESS) {
return ret;
}
int32_t sspParam[] = {
CRYPT_PARAM_KDF_KEY, CRYPT_PARAM_KDF_PRK, CRYPT_PARAM_KDF_INFO
};
return SSPLog(ctx, param, sspParam, sizeof(sspParam)/sizeof(sspParam[0]));
}
#endif
static int32_t CheckPBKDF2ParamAndLog(IsoKdfCtx *ctx, const BSL_Param *param)
{
int32_t ret = CheckKdfParam(ctx, param);
if (ret != CRYPT_SUCCESS) {
return ret;
}
int32_t sspParam[] = {CRYPT_PARAM_KDF_PASSWORD};
return SSPLog(ctx, param, sspParam, sizeof(sspParam)/sizeof(sspParam[0]));
}
static int32_t CheckDeriveKeyLen(IsoKdfCtx *ctx, uint32_t len)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
if (ctx->algId != CRYPT_KDF_PBKDF2) {
return CRYPT_SUCCESS;
}
CRYPT_EAL_Pbkdf2Param pbkdf2Param = {KDF_DEF_MAC_ALGID, KDF_DEF_SALT_LEN, KDF_DEF_PBKDF2_ITER, len};
CRYPT_EAL_KdfC2Data data = {&pbkdf2Param, NULL};
if (!CMVP_Iso19790KdfC2(CRYPT_KDF_PBKDF2, &data)) {
BSL_ERR_PUSH_ERROR(CRYPT_CMVP_ERR_PARAM_CHECK);
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_KDF, ctx->algId);
return CRYPT_CMVP_ERR_PARAM_CHECK;
}
return CRYPT_SUCCESS;
}
#define KDF_METHOD_FUNC(name) \
static void *CRYPT_##name##_NewCtxExWrapper(CRYPT_EAL_IsoProvCtx *provCtx, int32_t algId) \
{ \
if (provCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return NULL; \
} \
void *kdfCtx = CRYPT_##name##_NewCtxEx(provCtx->libCtx); \
if (kdfCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
IsoKdfCtx *ctx = BSL_SAL_Calloc(1, sizeof(IsoKdfCtx)); \
if (ctx == NULL) { \
CRYPT_##name##_FreeCtx(kdfCtx); \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
ctx->algId = algId; \
ctx->ctx = kdfCtx; \
ctx->provCtx = provCtx; \
return ctx; \
} \
\
static int32_t CRYPT_##name##_SetParamWrapper(IsoKdfCtx *ctx, const BSL_Param *param) \
{ \
if (ctx == NULL || param == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = Check##name##ParamAndLog(ctx, param); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_SetParam(ctx->ctx, param); \
} \
\
static int32_t CRYPT_##name##_DeriveWrapper(IsoKdfCtx *ctx, uint8_t *out, uint32_t len) \
{ \
int32_t ret = CheckDeriveKeyLen(ctx, len); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_KDF, CRYPT_ALGO_KDF, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_Derive(ctx->ctx, out, len); \
} \
\
static int32_t CRYPT_##name##_DeinitWrapper(IsoKdfCtx *ctx) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ZERO, CRYPT_ALGO_KDF, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_Deinit(ctx->ctx); \
} \
\
static void CRYPT_##name##_FreeCtxWrapper(IsoKdfCtx *ctx) \
{ \
if (ctx == NULL) { \
return; \
} \
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ZERO, CRYPT_ALGO_KDF, ctx->algId); \
if (ctx->ctx != NULL) { \
CRYPT_##name##_FreeCtx(ctx->ctx); \
} \
BSL_SAL_Free(ctx); \
}
#ifdef HITLS_CRYPTO_SCRYPT
KDF_METHOD_FUNC(SCRYPT);
#endif
#ifdef HITLS_CRYPTO_PBKDF2
KDF_METHOD_FUNC(PBKDF2);
#endif
#ifdef HITLS_CRYPTO_KDFTLS12
KDF_METHOD_FUNC(KDFTLS12);
#endif
#ifdef HITLS_CRYPTO_HKDF
KDF_METHOD_FUNC(HKDF);
#endif
const CRYPT_EAL_Func g_isoKdfScrypt[] = {
#ifdef HITLS_CRYPTO_SCRYPT
{CRYPT_EAL_IMPLKDF_NEWCTX, (CRYPT_EAL_ImplKdfNewCtx)CRYPT_SCRYPT_NewCtxExWrapper},
{CRYPT_EAL_IMPLKDF_SETPARAM, (CRYPT_EAL_ImplKdfSetParam)CRYPT_SCRYPT_SetParamWrapper},
{CRYPT_EAL_IMPLKDF_DERIVE, (CRYPT_EAL_ImplKdfDerive)CRYPT_SCRYPT_DeriveWrapper},
{CRYPT_EAL_IMPLKDF_DEINITCTX, (CRYPT_EAL_ImplKdfDeInitCtx)CRYPT_SCRYPT_DeinitWrapper},
{CRYPT_EAL_IMPLKDF_FREECTX, (CRYPT_EAL_ImplKdfFreeCtx)CRYPT_SCRYPT_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKdfPBKdf2[] = {
#ifdef HITLS_CRYPTO_PBKDF2
{CRYPT_EAL_IMPLKDF_NEWCTX, (CRYPT_EAL_ImplKdfNewCtx)CRYPT_PBKDF2_NewCtxExWrapper},
{CRYPT_EAL_IMPLKDF_SETPARAM, (CRYPT_EAL_ImplKdfSetParam)CRYPT_PBKDF2_SetParamWrapper},
{CRYPT_EAL_IMPLKDF_DERIVE, (CRYPT_EAL_ImplKdfDerive)CRYPT_PBKDF2_DeriveWrapper},
{CRYPT_EAL_IMPLKDF_DEINITCTX, (CRYPT_EAL_ImplKdfDeInitCtx)CRYPT_PBKDF2_DeinitWrapper},
{CRYPT_EAL_IMPLKDF_FREECTX, (CRYPT_EAL_ImplKdfFreeCtx)CRYPT_PBKDF2_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKdfKdfTLS12[] = {
#ifdef HITLS_CRYPTO_KDFTLS12
{CRYPT_EAL_IMPLKDF_NEWCTX, (CRYPT_EAL_ImplKdfNewCtx)CRYPT_KDFTLS12_NewCtxExWrapper},
{CRYPT_EAL_IMPLKDF_SETPARAM, (CRYPT_EAL_ImplKdfSetParam)CRYPT_KDFTLS12_SetParamWrapper},
{CRYPT_EAL_IMPLKDF_DERIVE, (CRYPT_EAL_ImplKdfDerive)CRYPT_KDFTLS12_DeriveWrapper},
{CRYPT_EAL_IMPLKDF_DEINITCTX, (CRYPT_EAL_ImplKdfDeInitCtx)CRYPT_KDFTLS12_DeinitWrapper},
{CRYPT_EAL_IMPLKDF_FREECTX, (CRYPT_EAL_ImplKdfFreeCtx)CRYPT_KDFTLS12_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKdfHkdf[] = {
#ifdef HITLS_CRYPTO_HKDF
{CRYPT_EAL_IMPLKDF_NEWCTX, (CRYPT_EAL_ImplKdfNewCtx)CRYPT_HKDF_NewCtxExWrapper},
{CRYPT_EAL_IMPLKDF_SETPARAM, (CRYPT_EAL_ImplKdfSetParam)CRYPT_HKDF_SetParamWrapper},
{CRYPT_EAL_IMPLKDF_DERIVE, (CRYPT_EAL_ImplKdfDerive)CRYPT_HKDF_DeriveWrapper},
{CRYPT_EAL_IMPLKDF_DEINITCTX, (CRYPT_EAL_ImplKdfDeInitCtx)CRYPT_HKDF_DeinitWrapper},
{CRYPT_EAL_IMPLKDF_FREECTX, (CRYPT_EAL_ImplKdfFreeCtx)CRYPT_HKDF_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */ | 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/iso_prov/crypt_iso_kdf.c | C | unknown | 17,063 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#ifdef HITLS_CRYPTO_MLKEM
#include "crypt_mlkem.h"
#endif
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provderimpl.h"
#ifdef HITLS_CRYPTO_MLKEM
static int32_t CRYPT_ML_KEM_EncapsWrapper(const CRYPT_Iso_Pkey_Ctx *ctx, uint8_t *cipher, uint32_t *cipherLen,
uint8_t *share, uint32_t *shareLen)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ENCAPS, CRYPT_ALGO_PKEY, ctx->algId);
if (ret != CRYPT_SUCCESS) {
return ret;
}
return CRYPT_ML_KEM_Encaps(ctx->ctx, cipher, cipherLen, share, shareLen);
}
static int32_t CRYPT_ML_KEM_DecapsWrapper(const CRYPT_Iso_Pkey_Ctx *ctx, uint8_t *cipher, uint32_t cipherLen,
uint8_t *share, uint32_t *shareLen)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_DECAPS, CRYPT_ALGO_PKEY, ctx->algId);
if (ret != CRYPT_SUCCESS) {
return ret;
}
return CRYPT_ML_KEM_Decaps(ctx->ctx, cipher, cipherLen, share, shareLen);
}
#endif
const CRYPT_EAL_Func g_isoMlKem[] = {
#ifdef HITLS_CRYPTO_MLKEM
{CRYPT_EAL_IMPLPKEYKEM_ENCAPSULATE, (CRYPT_EAL_ImplPkeyKemEncapsulate)CRYPT_ML_KEM_EncapsWrapper},
{CRYPT_EAL_IMPLPKEYKEM_DECAPSULATE, (CRYPT_EAL_ImplPkeyKemDecapsulate)CRYPT_ML_KEM_DecapsWrapper},
#endif
CRYPT_EAL_FUNC_END
};
#endif // HITLS_CRYPTO_CMVP_ISO19790
| 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/iso_prov/crypt_iso_kem.c | C | unknown | 2,186 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#include "crypt_curve25519.h"
#include "crypt_dh.h"
#include "crypt_ecdh.h"
#include "crypt_sm2.h"
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provderimpl.h"
#define KEY_EXCH_FUNC(name) \
static int32_t name##Wrapper(const CRYPT_Iso_Pkey_Ctx *prvKey, const CRYPT_Iso_Pkey_Ctx *pubKey, \
uint8_t *sharedKey, uint32_t *shareKeyLen) \
{ \
if (prvKey == NULL || pubKey == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(prvKey->provCtx, CRYPT_EVENT_KEYAGGREMENT, CRYPT_ALGO_PKEY, prvKey->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return (name)(prvKey->ctx, pubKey->ctx, sharedKey, shareKeyLen); \
}
#ifdef HITLS_CRYPTO_X25519
KEY_EXCH_FUNC(CRYPT_CURVE25519_ComputeSharedKey)
#endif
#ifdef HITLS_CRYPTO_DH
KEY_EXCH_FUNC(CRYPT_DH_ComputeShareKey)
#endif
#ifdef HITLS_CRYPTO_ECDH
KEY_EXCH_FUNC(CRYPT_ECDH_ComputeShareKey)
#endif
#ifdef HITLS_CRYPTO_SM2_EXCH
KEY_EXCH_FUNC(CRYPT_SM2_KapComputeKey)
#endif
const CRYPT_EAL_Func g_isoExchX25519[] = {
#ifdef HITLS_CRYPTO_X25519
{CRYPT_EAL_IMPLPKEYEXCH_EXCH, (CRYPT_EAL_ImplPkeyExch)CRYPT_CURVE25519_ComputeSharedKeyWrapper},
#endif
CRYPT_EAL_FUNC_END
};
const CRYPT_EAL_Func g_isoExchDh[] = {
#ifdef HITLS_CRYPTO_DH
{CRYPT_EAL_IMPLPKEYEXCH_EXCH, (CRYPT_EAL_ImplPkeyExch)CRYPT_DH_ComputeShareKeyWrapper},
#endif
CRYPT_EAL_FUNC_END
};
const CRYPT_EAL_Func g_isoExchEcdh[] = {
#ifdef HITLS_CRYPTO_ECDH
{CRYPT_EAL_IMPLPKEYEXCH_EXCH, (CRYPT_EAL_ImplPkeyExch)CRYPT_ECDH_ComputeShareKeyWrapper},
#endif
CRYPT_EAL_FUNC_END
};
const CRYPT_EAL_Func g_isoExchSm2[] = {
#if defined(HITLS_CRYPTO_SM2_EXCH)
{CRYPT_EAL_IMPLPKEYEXCH_EXCH, (CRYPT_EAL_ImplPkeyExch)CRYPT_SM2_KapComputeKeyWrapper},
#endif
CRYPT_EAL_FUNC_END
};
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */ | 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/iso_prov/crypt_iso_keyexch.c | C | unknown | 3,481 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#ifdef HITLS_CRYPTO_DSA
#include "crypt_dsa.h"
#endif
#ifdef HITLS_CRYPTO_CURVE25519
#include "crypt_curve25519.h"
#endif
#ifdef HITLS_CRYPTO_RSA
#include "crypt_rsa.h"
#endif
#ifdef HITLS_CRYPTO_DH
#include "crypt_dh.h"
#endif
#ifdef HITLS_CRYPTO_ECDSA
#include "crypt_ecdsa.h"
#endif
#ifdef HITLS_CRYPTO_ECDH
#include "crypt_ecdh.h"
#endif
#ifdef HITLS_CRYPTO_SM2
#include "crypt_sm2.h"
#endif
#ifdef HITLS_CRYPTO_SLH_DSA
#include "crypt_slh_dsa.h"
#endif
#ifdef HITLS_CRYPTO_MLKEM
#include "crypt_mlkem.h"
#endif
#ifdef HITLS_CRYPTO_MLDSA
#include "crypt_mldsa.h"
#endif
#include "crypt_errno.h"
#include "bsl_err_internal.h"
#include "crypt_ealinit.h"
#include "crypt_iso_provider.h"
#include "crypt_eal_pkey.h"
#include "crypt_cmvp.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provderimpl.h"
#include "cmvp_iso19790.h"
#define PKEY_PCT_PARAM_COUNT 4
static int32_t ParaCheckAndLog(const CRYPT_Iso_Pkey_Ctx *ctx, const CRYPT_EAL_PkeyPara *para)
{
CRYPT_EAL_PkeyC2Data data = {para, NULL, NULL, CRYPT_MD_MAX, CRYPT_PKEY_PARAID_MAX, CRYPT_EVENT_MAX,
NULL, NULL, NULL};
if (!CMVP_Iso19790PkeyC2(ctx->algId, &data)) {
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_PKEY, ctx->algId);
return CRYPT_CMVP_ERR_PARAM_CHECK;
}
return CRYPT_SUCCESS;
}
static int32_t GetParamValue(const BSL_Param *params, int32_t paramId, uint8_t **value, uint32_t *valueLen)
{
const BSL_Param *param = BSL_PARAM_FindConstParam(params, paramId);
if (param == NULL || (param->value == NULL && param->valueLen != 0)) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
*value = param->value;
*valueLen = param->valueLen;
return CRYPT_SUCCESS;
}
static int32_t CheckDsaPara(const CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params)
{
CRYPT_EAL_PkeyPara para = {0};
int32_t ret = GetParamValue(params, CRYPT_PARAM_DSA_P, ¶.para.dsaPara.p, ¶.para.dsaPara.pLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
ret = GetParamValue(params, CRYPT_PARAM_DSA_Q, ¶.para.dsaPara.q, ¶.para.dsaPara.qLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
ret = GetParamValue(params, CRYPT_PARAM_DSA_G, ¶.para.dsaPara.g, ¶.para.dsaPara.gLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
return ParaCheckAndLog(ctx, ¶);
}
static int32_t GetRsaBits(const BSL_Param *params, uint32_t *bits)
{
uint32_t bitsLen = sizeof(*bits);
const BSL_Param *temp = BSL_PARAM_FindConstParam(params, CRYPT_PARAM_RSA_BITS);
if (temp == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
int32_t ret = BSL_PARAM_GetValue(temp, CRYPT_PARAM_RSA_BITS, BSL_PARAM_TYPE_UINT32, bits, &bitsLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
return CRYPT_SUCCESS;
}
static int32_t CheckRsaPara(const CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params)
{
uint32_t bits = 0;
int32_t ret = GetRsaBits(params, &bits);
if (ret != CRYPT_SUCCESS) {
return ret;
}
CRYPT_EAL_PkeyPara para = {0};
para.para.rsaPara.bits = bits;
return ParaCheckAndLog(ctx, ¶);
}
static int32_t CheckDhPara(const CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params)
{
CRYPT_EAL_PkeyPara para = {0};
int32_t ret = GetParamValue(params, CRYPT_PARAM_DH_P, ¶.para.dhPara.p, ¶.para.dhPara.pLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
ret = GetParamValue(params, CRYPT_PARAM_DH_Q, ¶.para.dhPara.q, ¶.para.dhPara.qLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
return ParaCheckAndLog(ctx, ¶);
}
static int32_t CheckPkeyParam(const CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params)
{
switch (ctx->algId) {
case CRYPT_PKEY_DH:
return CheckDhPara(ctx, params);
case CRYPT_PKEY_DSA:
return CheckDsaPara(ctx, params);
case CRYPT_PKEY_RSA:
return CheckRsaPara(ctx, params);
default:
return CRYPT_SUCCESS;
}
}
static int32_t CheckSetRsaPrvKey(CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params)
{
CRYPT_EAL_PkeyPrv prv = {0};
int32_t ret = GetParamValue(params, CRYPT_PARAM_RSA_N, &prv.key.rsaPrv.n, &prv.key.rsaPrv.nLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
ret = GetParamValue(params, CRYPT_PARAM_RSA_D, &prv.key.rsaPrv.d, &prv.key.rsaPrv.dLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
CRYPT_EAL_PkeyC2Data data = {NULL, NULL, &prv, CRYPT_MD_MAX, CRYPT_PKEY_PARAID_MAX, CRYPT_EVENT_MAX,
NULL, NULL, NULL};
if (!CMVP_Iso19790PkeyC2(ctx->algId, &data)) {
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_PKEY, ctx->algId);
return CRYPT_CMVP_ERR_PARAM_CHECK;
}
return CRYPT_SUCCESS;
}
static int32_t CheckSetPrvKey(CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params)
{
if (ctx->algId == CRYPT_PKEY_RSA) {
return CheckSetRsaPrvKey(ctx, params);
}
return CRYPT_SUCCESS;
}
static int32_t CheckSetRsaPubKey(CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params)
{
CRYPT_EAL_PkeyPub pub = {0};
int32_t ret = GetParamValue(params, CRYPT_PARAM_RSA_N, &pub.key.rsaPub.n, &pub.key.rsaPub.nLen);
if (ret != CRYPT_SUCCESS) {
return ret;
}
CRYPT_EAL_PkeyC2Data data = {NULL, &pub, NULL, CRYPT_MD_MAX, CRYPT_PKEY_PARAID_MAX, CRYPT_EVENT_MAX,
NULL, NULL, NULL};
if (!CMVP_Iso19790PkeyC2(ctx->algId, &data)) {
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_PKEY, ctx->algId);
return CRYPT_CMVP_ERR_PARAM_CHECK;
}
return CRYPT_SUCCESS;
}
static int32_t CheckSetPubKey(CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params)
{
if (ctx->algId == CRYPT_PKEY_RSA) {
return CheckSetRsaPubKey(ctx, params);
}
return CRYPT_SUCCESS;
}
static int32_t CheckParaId(CRYPT_Iso_Pkey_Ctx *ctx, int32_t opt, void *val, uint32_t len)
{
if (opt != CRYPT_CTRL_SET_PARA_BY_ID) {
return CRYPT_SUCCESS;
}
if (val == NULL || len != sizeof(CRYPT_PKEY_ParaId)) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
CRYPT_EAL_PkeyC2Data data = {NULL, NULL, NULL, CRYPT_MD_MAX, *(CRYPT_PKEY_ParaId *)val, CRYPT_EVENT_MAX,
NULL, NULL, NULL};
if (!CMVP_Iso19790PkeyC2(ctx->algId, &data)) {
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_PKEY, ctx->algId);
return CRYPT_CMVP_ERR_PARAM_CHECK;
}
return CRYPT_SUCCESS;
}
static int32_t CheckRsaPadding(CRYPT_Iso_Pkey_Ctx *ctx, int32_t opt, void *val, uint32_t len)
{
if (ctx->algId != CRYPT_PKEY_RSA) {
return CRYPT_SUCCESS;
}
int32_t ret = CRYPT_SUCCESS;
do {
if (opt == CRYPT_CTRL_SET_RSA_RSAES_PKCSV15 || opt == CRYPT_CTRL_SET_RSA_RSAES_PKCSV15_TLS ||
opt == CRYPT_CTRL_SET_NO_PADDING) {
ret = CRYPT_CMVP_ERR_PARAM_CHECK;
break;
}
if (opt == CRYPT_CTRL_SET_RSA_PADDING) {
if (val == NULL || len != sizeof(int32_t)) {
ret = CRYPT_NULL_INPUT;
break;
}
int32_t padType = *(int32_t *)val;
if (padType != CRYPT_EMSA_PKCSV15 && padType != CRYPT_EMSA_PSS && padType != CRYPT_RSAES_OAEP) {
ret = CRYPT_CMVP_ERR_PARAM_CHECK;
break;
}
}
} while (0);
if (ret != CRYPT_SUCCESS) {
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_PKEY, ctx->algId);
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
static int32_t CheckRsaMdId(CRYPT_Iso_Pkey_Ctx *ctx, int32_t opt, void *val, uint32_t len)
{
CRYPT_RSA_PkcsV15Para pkcsv15 = {0};
CRYPT_EAL_PkeyC2Data data = {NULL, NULL, NULL, CRYPT_MD_MAX, CRYPT_PKEY_PARAID_MAX, CRYPT_EVENT_MAX,
NULL, NULL, NULL};
switch (opt) {
case CRYPT_CTRL_SET_RSA_EMSA_PKCSV15:
if (val == NULL || len != sizeof(int32_t)) {
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT);
return CRYPT_NULL_INPUT;
}
pkcsv15.mdId = *(int32_t *)val;
data.pkcsv15 = &pkcsv15;
break;
case CRYPT_CTRL_SET_RSA_EMSA_PSS:
data.pss = (BSL_Param *)val;
break;
case CRYPT_CTRL_SET_RSA_RSAES_OAEP:
data.oaep = (BSL_Param *)val;
break;
default:
return CRYPT_SUCCESS;
}
if (!CMVP_Iso19790PkeyC2(ctx->algId, &data)) {
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_PKEY, ctx->algId);
return CRYPT_CMVP_ERR_PARAM_CHECK;
}
return CRYPT_SUCCESS;
}
static int32_t PkeyCtrlCheck(CRYPT_Iso_Pkey_Ctx *ctx, int32_t opt, void *val, uint32_t len)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(CRYPT_INVALID_ARG);
return CRYPT_INVALID_ARG;
}
int32_t ret = CheckParaId(ctx, opt, val, len);
if (ret != CRYPT_SUCCESS) {
return ret;
}
ret = CheckRsaPadding(ctx, opt, val, len);
if (ret != CRYPT_SUCCESS) {
return ret;
}
return CheckRsaMdId(ctx, opt, val, len);
}
static int32_t CRYPT_ASMCAP_PkeyCheck(int32_t algId)
{
#ifdef HITLS_CRYPTO_ASM_CHECK
if (CRYPT_ASMCAP_Pkey(algId) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
}
#else
(void)algId;
#endif
return CRYPT_SUCCESS;
}
#define PKEY_NEW_Ctx_FUNC(name) \
static void *CRYPT_##name##_NewCtxExWrapper(CRYPT_EAL_IsoProvCtx *provCtx, int32_t algId) \
{ \
if (CRYPT_ASMCAP_PkeyCheck(algId) != CRYPT_SUCCESS) { \
return NULL; \
} \
if (provCtx == NULL || provCtx->libCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return NULL; \
} \
CRYPT_Iso_Pkey_Ctx *ctx = (CRYPT_Iso_Pkey_Ctx *)BSL_SAL_Calloc(1, sizeof(CRYPT_Iso_Pkey_Ctx)); \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
void *pkeyCtx = CRYPT_##name##_NewCtxEx(provCtx->libCtx); \
if (pkeyCtx == NULL) { \
BSL_SAL_Free(ctx); \
return NULL; \
} \
ctx->algId = algId; \
ctx->ctx = pkeyCtx; \
ctx->provCtx = provCtx; \
return ctx; \
}
#define PKEY_SET_PARA_FUNC(name) \
static int32_t CRYPT_##name##_SetParaWrapper(CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *param) \
{ \
if (ctx == NULL || param == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CheckPkeyParam(ctx, param); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_SetParaEx(ctx->ctx, param); \
}
#define PKEY_GET_PARA_FUNC(name) \
static int32_t CRYPT_##name##_GetParaWrapper(const CRYPT_Iso_Pkey_Ctx *ctx, BSL_Param *param) \
{ \
if (ctx == NULL || param == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CheckPkeyParam(ctx, param); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_GetParaEx(ctx->ctx, param); \
}
#define PKEY_GEN_KEY_FUNC(name) \
static int32_t name##Wrapper(CRYPT_Iso_Pkey_Ctx *ctx) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_GEN, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = (name)(ctx->ctx); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PCT_TEST, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
if (!CMVP_Iso19790PkeyPct(ctx)) { \
return CRYPT_CMVP_ERR_PAIRWISETEST; \
} \
return CRYPT_SUCCESS; \
}
#define PKEY_SET_KEY_FUNC(setPrvFunc, setPubFunc) \
static int32_t setPrvFunc##Wrapper(CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *para) \
{ \
if (ctx == NULL || para == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CheckSetPrvKey(ctx, para); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_SETSSP, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return (setPrvFunc)(ctx->ctx, para); \
} \
\
static int32_t setPubFunc##Wrapper(CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *para) \
{ \
if (ctx == NULL || para == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CheckSetPubKey(ctx, para); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_SETSSP, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return (setPubFunc)(ctx->ctx, para); \
}
#define PKEY_GET_KEY_FUNC(getPrvFunc, getPubFunc) \
static int32_t getPrvFunc##Wrapper(const CRYPT_Iso_Pkey_Ctx *ctx, BSL_Param *para) \
{ \
if (ctx == NULL || para == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_GETSSP, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return (getPrvFunc)(ctx->ctx, para); \
} \
\
static int32_t getPubFunc##Wrapper(const CRYPT_Iso_Pkey_Ctx *ctx, BSL_Param *para) \
{ \
if (ctx == NULL || para == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_GETSSP, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return (getPubFunc)(ctx->ctx, para); \
}
#define PKEY_DUP_CTX_FUNC(name) \
static CRYPT_Iso_Pkey_Ctx *CRYPT_##name##_DupCtxWrapper(CRYPT_Iso_Pkey_Ctx *ctx) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return NULL; \
} \
CRYPT_Iso_Pkey_Ctx *newCtx = (CRYPT_Iso_Pkey_Ctx *)BSL_SAL_Calloc(1, sizeof(CRYPT_Iso_Pkey_Ctx)); \
if (newCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
void *pkeyCtx = CRYPT_##name##_DupCtx(ctx->ctx); \
if (pkeyCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
BSL_SAL_Free(newCtx); \
return NULL; \
} \
newCtx->algId = ctx->algId; \
newCtx->ctx = pkeyCtx; \
newCtx->provCtx = ctx->provCtx; \
return newCtx; \
}
#define PKEY_CMP_FUNC(name) \
static int32_t CRYPT_##name##_CmpWrapper(const CRYPT_Iso_Pkey_Ctx *a, const CRYPT_Iso_Pkey_Ctx *b) \
{ \
if (a == NULL || b == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return CRYPT_##name##_Cmp(a->ctx, b->ctx); \
}
#define PKEY_CTRL_FUNC(name) \
static int32_t CRYPT_##name##_CtrlWrapper(CRYPT_Iso_Pkey_Ctx *ctx, int32_t opt, void *val, uint32_t len) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = PkeyCtrlCheck(ctx, opt, val, len); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_Ctrl(ctx->ctx, opt, val, len); \
}
#define PKEY_FREE_CTX_FUNC(name) \
static void CRYPT_##name##_FreeCtxWrapper(CRYPT_Iso_Pkey_Ctx *ctx) \
{ \
if (ctx == NULL) { \
return; \
} \
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ZERO, CRYPT_ALGO_PKEY, ctx->algId); \
if (ctx->algId == CRYPT_PKEY_SLH_DSA || ctx->algId == CRYPT_PKEY_ML_DSA || \
ctx->algId == CRYPT_PKEY_ML_KEM) { \
CRYPT_##name##_Ctrl(ctx->ctx, CRYPT_CTRL_CLEAN_PUB_KEY, NULL, 0); \
} \
if (ctx->ctx != NULL) { \
CRYPT_##name##_FreeCtx(ctx->ctx); \
} \
BSL_SAL_Free(ctx); \
}
#define PKEY_IMPORT_EXPORT_FUNC(name) \
static int32_t CRYPT_##name##_ImportWrapper(CRYPT_Iso_Pkey_Ctx *ctx, const BSL_Param *params) \
{ \
if (ctx == NULL || params == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_SETSSP, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_Import(ctx->ctx, params); \
} \
\
static int32_t CRYPT_##name##_ExportWrapper(const CRYPT_Iso_Pkey_Ctx *ctx, BSL_Param *params) \
{ \
if (ctx == NULL || params == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_GETSSP, CRYPT_ALGO_PKEY, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_Export(ctx->ctx, params); \
}
#define PKEY_CHECK_FUNC(name) \
static int32_t CRYPT_##name##_CheckWrapper(uint32_t checkType, const CRYPT_Iso_Pkey_Ctx *ctx1, \
const CRYPT_Iso_Pkey_Ctx *ctx2) \
{ \
return CRYPT_##name##_Check(checkType, ctx1 != NULL ? ctx1->ctx : NULL, \
ctx2 != NULL ? ctx2->ctx : NULL); \
}
PKEY_NEW_Ctx_FUNC(DSA)
PKEY_NEW_Ctx_FUNC(ED25519)
PKEY_NEW_Ctx_FUNC(X25519)
PKEY_NEW_Ctx_FUNC(RSA)
PKEY_NEW_Ctx_FUNC(DH)
PKEY_NEW_Ctx_FUNC(ECDSA)
PKEY_NEW_Ctx_FUNC(ECDH)
PKEY_NEW_Ctx_FUNC(SM2)
PKEY_NEW_Ctx_FUNC(SLH_DSA)
PKEY_NEW_Ctx_FUNC(ML_KEM)
PKEY_NEW_Ctx_FUNC(ML_DSA)
PKEY_SET_PARA_FUNC(DSA)
PKEY_SET_PARA_FUNC(RSA)
PKEY_SET_PARA_FUNC(DH)
PKEY_SET_PARA_FUNC(ECDSA)
PKEY_SET_PARA_FUNC(ECDH)
PKEY_GET_PARA_FUNC(DSA)
PKEY_GET_PARA_FUNC(DH)
PKEY_GET_PARA_FUNC(ECDSA)
PKEY_GET_PARA_FUNC(ECDH)
PKEY_GEN_KEY_FUNC(CRYPT_DSA_Gen)
PKEY_GEN_KEY_FUNC(CRYPT_ED25519_GenKey)
PKEY_GEN_KEY_FUNC(CRYPT_X25519_GenKey)
PKEY_GEN_KEY_FUNC(CRYPT_RSA_Gen)
PKEY_GEN_KEY_FUNC(CRYPT_DH_Gen)
PKEY_GEN_KEY_FUNC(CRYPT_ECDSA_Gen)
PKEY_GEN_KEY_FUNC(CRYPT_ECDH_Gen)
PKEY_GEN_KEY_FUNC(CRYPT_SM2_Gen)
PKEY_GEN_KEY_FUNC(CRYPT_SLH_DSA_Gen)
PKEY_GEN_KEY_FUNC(CRYPT_ML_KEM_GenKey)
PKEY_GEN_KEY_FUNC(CRYPT_ML_DSA_GenKey)
PKEY_SET_KEY_FUNC(CRYPT_DSA_SetPrvKeyEx, CRYPT_DSA_SetPubKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_CURVE25519_SetPrvKeyEx, CRYPT_CURVE25519_SetPubKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_RSA_SetPrvKeyEx, CRYPT_RSA_SetPubKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_DH_SetPrvKeyEx, CRYPT_DH_SetPubKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_ECDSA_SetPrvKeyEx, CRYPT_ECDSA_SetPubKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_ECDH_SetPrvKeyEx, CRYPT_ECDH_SetPubKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_SM2_SetPrvKeyEx, CRYPT_SM2_SetPubKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_ML_KEM_SetDecapsKeyEx, CRYPT_ML_KEM_SetEncapsKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_ML_DSA_SetPrvKeyEx, CRYPT_ML_DSA_SetPubKeyEx)
PKEY_SET_KEY_FUNC(CRYPT_SLH_DSA_SetPrvKeyEx, CRYPT_SLH_DSA_SetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_DSA_GetPrvKeyEx, CRYPT_DSA_GetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_CURVE25519_GetPrvKeyEx, CRYPT_CURVE25519_GetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_RSA_GetPrvKeyEx, CRYPT_RSA_GetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_DH_GetPrvKeyEx, CRYPT_DH_GetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_ECDSA_GetPrvKeyEx, CRYPT_ECDSA_GetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_ECDH_GetPrvKeyEx, CRYPT_ECDH_GetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_SM2_GetPrvKeyEx, CRYPT_SM2_GetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_ML_KEM_GetDecapsKeyEx, CRYPT_ML_KEM_GetEncapsKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_ML_DSA_GetPrvKeyEx, CRYPT_ML_DSA_GetPubKeyEx)
PKEY_GET_KEY_FUNC(CRYPT_SLH_DSA_GetPrvKeyEx, CRYPT_SLH_DSA_GetPubKeyEx)
PKEY_DUP_CTX_FUNC(DSA)
PKEY_DUP_CTX_FUNC(CURVE25519)
PKEY_DUP_CTX_FUNC(RSA)
PKEY_DUP_CTX_FUNC(DH)
PKEY_DUP_CTX_FUNC(ECDSA)
PKEY_DUP_CTX_FUNC(ECDH)
PKEY_DUP_CTX_FUNC(SM2)
PKEY_DUP_CTX_FUNC(ML_KEM)
PKEY_DUP_CTX_FUNC(ML_DSA)
PKEY_CMP_FUNC(DSA)
PKEY_CMP_FUNC(CURVE25519)
PKEY_CMP_FUNC(RSA)
PKEY_CMP_FUNC(DH)
PKEY_CMP_FUNC(ECDSA)
PKEY_CMP_FUNC(ECDH)
PKEY_CMP_FUNC(SM2)
PKEY_CMP_FUNC(ML_KEM)
PKEY_CMP_FUNC(ML_DSA)
PKEY_CTRL_FUNC(DSA)
PKEY_CTRL_FUNC(CURVE25519)
PKEY_CTRL_FUNC(RSA)
PKEY_CTRL_FUNC(DH)
PKEY_CTRL_FUNC(ECDSA)
PKEY_CTRL_FUNC(ECDH)
PKEY_CTRL_FUNC(SM2)
PKEY_CTRL_FUNC(ML_KEM)
PKEY_CTRL_FUNC(ML_DSA)
PKEY_CTRL_FUNC(SLH_DSA)
PKEY_FREE_CTX_FUNC(DSA)
PKEY_FREE_CTX_FUNC(CURVE25519)
PKEY_FREE_CTX_FUNC(RSA)
PKEY_FREE_CTX_FUNC(DH)
PKEY_FREE_CTX_FUNC(ECDSA)
PKEY_FREE_CTX_FUNC(ECDH)
PKEY_FREE_CTX_FUNC(SM2)
PKEY_FREE_CTX_FUNC(ML_KEM)
PKEY_FREE_CTX_FUNC(ML_DSA)
PKEY_FREE_CTX_FUNC(SLH_DSA)
PKEY_IMPORT_EXPORT_FUNC(CURVE25519)
PKEY_IMPORT_EXPORT_FUNC(RSA)
PKEY_IMPORT_EXPORT_FUNC(ECDSA)
PKEY_IMPORT_EXPORT_FUNC(SM2)
PKEY_CHECK_FUNC(DSA)
PKEY_CHECK_FUNC(ED25519)
PKEY_CHECK_FUNC(X25519)
PKEY_CHECK_FUNC(RSA)
PKEY_CHECK_FUNC(DH)
PKEY_CHECK_FUNC(ECDSA)
PKEY_CHECK_FUNC(ECDH)
PKEY_CHECK_FUNC(SM2)
PKEY_CHECK_FUNC(ML_KEM)
PKEY_CHECK_FUNC(ML_DSA)
PKEY_CHECK_FUNC(SLH_DSA)
const CRYPT_EAL_Func g_isoKeyMgmtDsa[] = {
#ifdef HITLS_CRYPTO_DSA
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_DSA_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)CRYPT_DSA_SetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPARAM, (CRYPT_EAL_ImplPkeyMgmtGetParam)CRYPT_DSA_GetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_DSA_GenWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_DSA_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_DSA_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_DSA_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_DSA_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_DSA_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_DSA_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_DSA_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_DSA_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_DSA_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtEd25519[] = {
#ifdef HITLS_CRYPTO_ED25519
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_ED25519_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_ED25519_GenKeyWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_CURVE25519_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_CURVE25519_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_CURVE25519_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_CURVE25519_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_CURVE25519_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_ED25519_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_CURVE25519_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_CURVE25519_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_CURVE25519_FreeCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_IMPORT, (CRYPT_EAL_ImplPkeyMgmtImport)CRYPT_CURVE25519_ImportWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_EXPORT, (CRYPT_EAL_ImplPkeyMgmtExport)CRYPT_CURVE25519_ExportWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtX25519[] = {
#ifdef HITLS_CRYPTO_X25519
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_X25519_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_X25519_GenKeyWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_CURVE25519_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_CURVE25519_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_CURVE25519_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_CURVE25519_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_CURVE25519_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_X25519_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_CURVE25519_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_CURVE25519_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_CURVE25519_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtRsa[] = {
#ifdef HITLS_CRYPTO_RSA
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_RSA_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)CRYPT_RSA_SetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_RSA_GenWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_RSA_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_RSA_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_RSA_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_RSA_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_RSA_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_RSA_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_RSA_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_RSA_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_RSA_FreeCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_IMPORT, (CRYPT_EAL_ImplPkeyMgmtImport)CRYPT_RSA_ImportWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_EXPORT, (CRYPT_EAL_ImplPkeyMgmtExport)CRYPT_RSA_ExportWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtDh[] = {
#ifdef HITLS_CRYPTO_DH
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_DH_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)CRYPT_DH_SetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPARAM, (CRYPT_EAL_ImplPkeyMgmtGetParam)CRYPT_DH_GetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_DH_GenWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_DH_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_DH_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_DH_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_DH_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_DH_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_DH_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_DH_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_DH_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_DH_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtEcdsa[] = {
#ifdef HITLS_CRYPTO_ECDSA
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_ECDSA_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)CRYPT_ECDSA_SetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPARAM, (CRYPT_EAL_ImplPkeyMgmtGetParam)CRYPT_ECDSA_GetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_ECDSA_GenWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_ECDSA_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_ECDSA_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_ECDSA_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_ECDSA_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_ECDSA_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_ECDSA_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_ECDSA_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_ECDSA_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_ECDSA_FreeCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_IMPORT, (CRYPT_EAL_ImplPkeyMgmtImport)CRYPT_ECDSA_ImportWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_EXPORT, (CRYPT_EAL_ImplPkeyMgmtExport)CRYPT_ECDSA_ExportWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtEcdh[] = {
#ifdef HITLS_CRYPTO_ECDH
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_ECDH_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)CRYPT_ECDH_SetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPARAM, (CRYPT_EAL_ImplPkeyMgmtGetParam)CRYPT_ECDH_GetParaWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_ECDH_GenWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_ECDH_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_ECDH_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_ECDH_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_ECDH_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_ECDH_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_ECDH_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_ECDH_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_ECDH_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_ECDH_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtSm2[] = {
#ifdef HITLS_CRYPTO_SM2
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_SM2_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_SM2_GenWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_SM2_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_SM2_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_SM2_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_SM2_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_SM2_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_SM2_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_SM2_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_SM2_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_SM2_FreeCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_IMPORT, (CRYPT_EAL_ImplPkeyMgmtImport)CRYPT_SM2_ImportWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_EXPORT, (CRYPT_EAL_ImplPkeyMgmtExport)CRYPT_SM2_ExportWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtMlKem[] = {
#ifdef HITLS_CRYPTO_MLKEM
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_ML_KEM_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_ML_KEM_GenKeyWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_ML_KEM_SetDecapsKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_ML_KEM_SetEncapsKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_ML_KEM_GetDecapsKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_ML_KEM_GetEncapsKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_ML_KEM_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_ML_KEM_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_ML_KEM_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_ML_KEM_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_ML_KEM_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtMlDsa[] = {
#ifdef HITLS_CRYPTO_MLDSA
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_ML_DSA_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_ML_DSA_GenKeyWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_ML_DSA_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_ML_DSA_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_ML_DSA_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_ML_DSA_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)CRYPT_ML_DSA_DupCtxWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_ML_DSA_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_COMPARE, (CRYPT_EAL_ImplPkeyMgmtCompare)CRYPT_ML_DSA_CmpWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_ML_DSA_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_ML_DSA_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoKeyMgmtSlhDsa[] = {
#ifdef HITLS_CRYPTO_SLH_DSA
{CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)CRYPT_SLH_DSA_NewCtxExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)CRYPT_SLH_DSA_GenWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)CRYPT_SLH_DSA_SetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)CRYPT_SLH_DSA_SetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)CRYPT_SLH_DSA_GetPrvKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)CRYPT_SLH_DSA_GetPubKeyExWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CHECK, (CRYPT_EAL_ImplPkeyMgmtCheck)CRYPT_SLH_DSA_CheckWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)CRYPT_SLH_DSA_CtrlWrapper},
{CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)CRYPT_SLH_DSA_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */ | 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/iso_prov/crypt_iso_keymgmt.c | C | unknown | 52,129 |
/*
* This file is part of the openHiTLS project.
*
* openHiTLS is licensed under the Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "hitls_build.h"
#ifdef HITLS_CRYPTO_CMVP_ISO19790
#include "crypt_eal_implprovider.h"
#include "crypt_hmac.h"
#include "crypt_cmac.h"
#include "crypt_cbc_mac.h"
#include "crypt_gmac.h"
#include "crypt_siphash.h"
#include "crypt_ealinit.h"
#include "bsl_sal.h"
#include "crypt_errno.h"
#include "bsl_log_internal.h"
#include "bsl_err_internal.h"
#include "cmvp_iso19790.h"
#include "crypt_iso_selftest.h"
#include "crypt_iso_provider.h"
#define MAC_KEY_LEN_MIN 14
typedef struct {
int32_t algId;
void *ctx;
void *provCtx;
} IsoMacCtx;
static int32_t CRYPT_ASMCAP_MacCheck(int32_t algId)
{
#ifdef HITLS_CRYPTO_ASM_CHECK
if (CRYPT_ASMCAP_Mac(algId) != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
}
#else
(void)algId;
#endif
return CRYPT_SUCCESS;
}
static int32_t CheckMacKeyLen(IsoMacCtx *ctx, uint32_t keyLen)
{
if (!CMVP_Iso19790MacC2(ctx->algId, keyLen)) {
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_PARAM_CHECK, CRYPT_ALGO_MAC, ctx->algId);
BSL_ERR_PUSH_ERROR(CRYPT_CMVP_ERR_PARAM_CHECK);
return CRYPT_CMVP_ERR_PARAM_CHECK;
}
return CRYPT_SUCCESS;
}
#define MAC_NewCtx_FUNC(name) \
static void *CRYPT_##name##_NewCtxExWrapper(CRYPT_EAL_IsoProvCtx *provCtx, int32_t algId) \
{ \
if (CRYPT_ASMCAP_MacCheck(algId) != CRYPT_SUCCESS) { \
return NULL; \
} \
if (provCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return NULL; \
} \
void *macCtx = CRYPT_##name##_NewCtxEx(provCtx->libCtx, algId); \
if (macCtx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
IsoMacCtx *ctx = BSL_SAL_Calloc(1, sizeof(IsoMacCtx)); \
if (ctx == NULL) { \
CRYPT_##name##_FreeCtx(macCtx); \
BSL_ERR_PUSH_ERROR(CRYPT_MEM_ALLOC_FAIL); \
return NULL; \
} \
ctx->algId = algId; \
ctx->ctx = macCtx; \
ctx->provCtx = provCtx; \
return ctx; \
}
#define MAC_INIT_FUNC(name) \
static int32_t CRYPT_##name##_InitWrapper(IsoMacCtx *ctx, const uint8_t *key, uint32_t len, void *param) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
int32_t ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_MAC, CRYPT_ALGO_MAC, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = CheckMacKeyLen(ctx, len); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
ret = CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_SETSSP, CRYPT_ALGO_MAC, ctx->algId); \
if (ret != CRYPT_SUCCESS) { \
return ret; \
} \
return CRYPT_##name##_Init(ctx->ctx, key, len, param); \
}
#define MAC_Update_FUNC(name) \
static int32_t CRYPT_##name##_UpdateWrapper(IsoMacCtx *ctx, const uint8_t *in, uint32_t len) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return CRYPT_##name##_Update(ctx->ctx, in, len); \
}
#define MAC_Final_FUNC(name) \
static int32_t CRYPT_##name##_FinalWrapper(IsoMacCtx *ctx, uint8_t *out, uint32_t *len) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return CRYPT_##name##_Final(ctx->ctx, out, len); \
}
#define MAC_Ctrl_FUNC(name) \
static int32_t CRYPT_##name##_CtrlWrapper(IsoMacCtx *ctx, CRYPT_MacCtrl opt, void *val, uint32_t len) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return CRYPT_##name##_Ctrl(ctx->ctx, opt, val, len); \
}
#define MAC_FreeCtx_FUNC(name) \
static void CRYPT_##name##_FreeCtxWrapper(IsoMacCtx *ctx) \
{ \
if (ctx == NULL) { \
return; \
} \
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ZERO, CRYPT_ALGO_MAC, ctx->algId); \
if (ctx->ctx != NULL) { \
CRYPT_##name##_FreeCtx(ctx->ctx); \
} \
BSL_SAL_Free(ctx); \
}
#define MAC_DEINIT_FUNC(name) \
static int32_t CRYPT_##name##_DeinitWrapper(IsoMacCtx *ctx) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
(void)CRYPT_Iso_Log(ctx->provCtx, CRYPT_EVENT_ZERO, CRYPT_ALGO_MAC, ctx->algId); \
return CRYPT_##name##_Deinit(ctx->ctx); \
}
#define MAC_REINIT_FUNC(name) \
static int32_t CRYPT_##name##_ReinitWrapper(IsoMacCtx *ctx) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return CRYPT_##name##_Reinit(ctx->ctx); \
}
#define MAC_SET_PARAM_FUNC(name) \
static int32_t CRYPT_##name##_SetParamWrapper(IsoMacCtx *ctx, const BSL_Param *param) \
{ \
if (ctx == NULL) { \
BSL_ERR_PUSH_ERROR(CRYPT_NULL_INPUT); \
return CRYPT_NULL_INPUT; \
} \
return CRYPT_##name##_SetParam(ctx->ctx, param); \
}
#define MAC_FUNCS(name) \
MAC_NewCtx_FUNC(name) \
MAC_INIT_FUNC(name) \
MAC_Update_FUNC(name) \
MAC_Final_FUNC(name) \
MAC_DEINIT_FUNC(name) \
MAC_Ctrl_FUNC(name) \
MAC_FreeCtx_FUNC(name)
#ifdef HITLS_CRYPTO_HMAC
MAC_FUNCS(HMAC)
MAC_REINIT_FUNC(HMAC)
MAC_SET_PARAM_FUNC(HMAC)
#endif
#ifdef HITLS_CRYPTO_CMAC
MAC_FUNCS(CMAC)
MAC_REINIT_FUNC(CMAC)
#endif
#ifdef HITLS_CRYPTO_GMAC
MAC_FUNCS(GMAC)
#endif
const CRYPT_EAL_Func g_isoMacHmac[] = {
#ifdef HITLS_CRYPTO_HMAC
{CRYPT_EAL_IMPLMAC_NEWCTX, (CRYPT_EAL_ImplMacNewCtx)CRYPT_HMAC_NewCtxExWrapper},
{CRYPT_EAL_IMPLMAC_INIT, (CRYPT_EAL_ImplMacInit)CRYPT_HMAC_InitWrapper},
{CRYPT_EAL_IMPLMAC_UPDATE, (CRYPT_EAL_ImplMacUpdate)CRYPT_HMAC_UpdateWrapper},
{CRYPT_EAL_IMPLMAC_FINAL, (CRYPT_EAL_ImplMacFinal)CRYPT_HMAC_FinalWrapper},
{CRYPT_EAL_IMPLMAC_DEINITCTX, (CRYPT_EAL_ImplMacDeInitCtx)CRYPT_HMAC_DeinitWrapper},
{CRYPT_EAL_IMPLMAC_REINITCTX, (CRYPT_EAL_ImplMacReInitCtx)CRYPT_HMAC_ReinitWrapper},
{CRYPT_EAL_IMPLMAC_CTRL, (CRYPT_EAL_ImplMacCtrl)CRYPT_HMAC_CtrlWrapper},
{CRYPT_EAL_IMPLMAC_FREECTX, (CRYPT_EAL_ImplMacFreeCtx)CRYPT_HMAC_FreeCtxWrapper},
{CRYPT_EAL_IMPLMAC_SETPARAM, (CRYPT_EAL_ImplMacSetParam)CRYPT_HMAC_SetParamWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoMacCmac[] = {
#ifdef HITLS_CRYPTO_CMAC
{CRYPT_EAL_IMPLMAC_NEWCTX, (CRYPT_EAL_ImplMacNewCtx)CRYPT_CMAC_NewCtxExWrapper},
{CRYPT_EAL_IMPLMAC_INIT, (CRYPT_EAL_ImplMacInit)CRYPT_CMAC_InitWrapper},
{CRYPT_EAL_IMPLMAC_UPDATE, (CRYPT_EAL_ImplMacUpdate)CRYPT_CMAC_UpdateWrapper},
{CRYPT_EAL_IMPLMAC_FINAL, (CRYPT_EAL_ImplMacFinal)CRYPT_CMAC_FinalWrapper},
{CRYPT_EAL_IMPLMAC_DEINITCTX, (CRYPT_EAL_ImplMacDeInitCtx)CRYPT_CMAC_DeinitWrapper},
{CRYPT_EAL_IMPLMAC_REINITCTX, (CRYPT_EAL_ImplMacReInitCtx)CRYPT_CMAC_ReinitWrapper},
{CRYPT_EAL_IMPLMAC_CTRL, (CRYPT_EAL_ImplMacCtrl)CRYPT_CMAC_CtrlWrapper},
{CRYPT_EAL_IMPLMAC_FREECTX, (CRYPT_EAL_ImplMacFreeCtx)CRYPT_CMAC_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
const CRYPT_EAL_Func g_isoMacGmac[] = {
#ifdef HITLS_CRYPTO_GMAC
{CRYPT_EAL_IMPLMAC_NEWCTX, (CRYPT_EAL_ImplMacNewCtx)CRYPT_GMAC_NewCtxExWrapper},
{CRYPT_EAL_IMPLMAC_INIT, (CRYPT_EAL_ImplMacInit)CRYPT_GMAC_InitWrapper},
{CRYPT_EAL_IMPLMAC_UPDATE, (CRYPT_EAL_ImplMacUpdate)CRYPT_GMAC_UpdateWrapper},
{CRYPT_EAL_IMPLMAC_FINAL, (CRYPT_EAL_ImplMacFinal)CRYPT_GMAC_FinalWrapper},
{CRYPT_EAL_IMPLMAC_DEINITCTX, (CRYPT_EAL_ImplMacDeInitCtx)CRYPT_GMAC_DeinitWrapper},
{CRYPT_EAL_IMPLMAC_REINITCTX, NULL},
{CRYPT_EAL_IMPLMAC_CTRL, (CRYPT_EAL_ImplMacCtrl)CRYPT_GMAC_CtrlWrapper},
{CRYPT_EAL_IMPLMAC_FREECTX, (CRYPT_EAL_ImplMacFreeCtx)CRYPT_GMAC_FreeCtxWrapper},
#endif
CRYPT_EAL_FUNC_END,
};
#endif /* HITLS_CRYPTO_CMVP_ISO19790 */ | 2401_83913325/openHiTLS-examples_2461 | crypto/provider/src/cmvp/iso_prov/crypt_iso_mac.c | C | unknown | 16,515 |