auth_privpass_token.h

/*
 * 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 AUTH_PRIVPASS_TOKEN_H
#define AUTH_PRIVPASS_TOKEN_H
 
#include <stdint.h>
#include "bsl_params.h"
#include "bsl_obj.h"
 
#ifdef __cplusplus
extern "C" {
#endif

typedef struct PrivPass_Ctx HITLS_AUTH_PrivPassCtx;

typedef struct PrivPass_Token HITLS_AUTH_PrivPassToken;
 
/* Token types for different stages of the Private Pass protocol */
typedef enum {
    HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE_REQUEST = 1, // Initial request for challenge
    HITLS_AUTH_PRIVPASS_TOKEN_CHALLENGE = 2,         // Challenge from server
    HITLS_AUTH_PRIVPASS_TOKEN_REQUEST = 3,           // Token request with blinded message
    HITLS_AUTH_PRIVPASS_TOKEN_RESPONSE = 4,          // Server's response with blind signature
    HITLS_AUTH_PRIVPASS_TOKEN_INSTANCE = 5,          // Final token instance
} HITLS_AUTH_PrivPassTokenType;
 
/* Token types for different stages of the Private Pass protocol */
typedef enum {
    HITLS_AUTH_PRIVPASS_PRV_VERIFY_TOKENS = 1, // Private key verification tokens
    HITLS_AUTH_PRIVPASS_PUB_VERIFY_TOKENS = 2, // Public key verification tokens
} HITLS_AUTH_PrivPassType;
 
/* Commands for token operations and parameter retrieval */
typedef enum {
    HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGEREQUEST_INFO = 1,    
    HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGE_TYPE = 2,    
    HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGE_ISSUERNAME = 3,    
    HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGE_REDEMPTION = 4,    
    HITLS_AUTH_PRIVPASS_GET_TOKENCHALLENGE_ORIGININFO = 5,    
    HITLS_AUTH_PRIVPASS_GET_TOKENREQUEST_TYPE = 6,    
    HITLS_AUTH_PRIVPASS_GET_TOKENREQUEST_TRUNCATEDTOKENKEYID = 7, 
    HITLS_AUTH_PRIVPASS_GET_TOKENREQUEST_BLINDEDMSG = 8,    
    HITLS_AUTH_PRIVPASS_GET_TOKENRESPONSE_INFO = 9,    
    HITLS_AUTH_PRIVPASS_GET_TOKEN_TYPE = 10,    
    HITLS_AUTH_PRIVPASS_GET_TOKEN_NONCE = 11,    
    HITLS_AUTH_PRIVPASS_GET_TOKEN_CHALLENGEDIGEST = 12,    
    HITLS_AUTH_PRIVPASS_GET_TOKEN_TOKENKEYID = 13,    
    HITLS_AUTH_PRIVPASS_GET_TOKEN_AUTHENTICATOR = 14,    
    HITLS_AUTH_PRIVPASS_GET_CTX_TOKENKEYID = 15,    
    HITLS_AUTH_PRIVPASS_GET_CTX_TRUNCATEDTOKENKEYID = 16,    
    HITLS_AUTH_PRIVPASS_GET_CTX_NONCE = 17,    
} HITLS_AUTH_PrivPassCmd;
 
typedef enum {
    HITLS_AUTH_PRIVPASS_CRYPTO_RSA = BSL_CID_RSA,
    HITLS_AUTH_PRIVPASS_CRYPTO_SHA256 = BSL_CID_SHA256,
    HITLS_AUTH_PRIVPASS_CRYPTO_SHA384 = BSL_CID_SHA384,
} HITLS_AUTH_PrivPassCryptAlgId;
 
typedef enum {
    HITLS_AUTH_PRIVPASS_NEW_PKEY_CTX_CB = 1,
    HITLS_AUTH_PRIVPASS_FREE_PKEY_CTX_CB = 2,
    HITLS_AUTH_PRIVPASS_DIGEST_CB = 3,
    HITLS_AUTH_PRIVPASS_BLIND_CB = 4,
    HITLS_AUTH_PRIVPASS_UNBLIND_CB = 5,
    HITLS_AUTH_PRIVPASS_SIGNDATA_CB = 6,
    HITLS_AUTH_PRIVPASS_VERIFY_CB = 7,
    HITLS_AUTH_PRIVPASS_DECODE_PUBKEY_CB = 8,
    HITLS_AUTH_PRIVPASS_DECODE_PRVKEY_CB = 9,
    HITLS_AUTH_PRIVPASS_CHECK_KEYPAIR_CB = 10,
    HITLS_AUTH_PRIVPASS_RANDOM_CB = 11,
} HITLS_AUTH_PrivPassCryptCbType;

typedef void *(*HITLS_AUTH_PrivPassNewPkeyCtx)(void *libCtx, const char *attrName, int32_t algId);

typedef void (*HITLS_AUTH_PrivPassFreePkeyCtx)(void *pkeyCtx);

typedef int32_t (*HITLS_AUTH_PrivPassDigest)(void *libCtx, const char *attrName, int32_t algId, const uint8_t *input,
    uint32_t inputLen, uint8_t *digest, uint32_t *digestLen);

typedef int32_t (*HITLS_AUTH_PrivPassBlind)(void *pkeyCtx, int32_t algId, const uint8_t *data,
    uint32_t dataLen, uint8_t *blindedData, uint32_t *blindedDataLen);

typedef int32_t (*HITLS_AUTH_PrivPassUnblind)(void *pkeyCtx, const uint8_t *blindedData,
    uint32_t blindedDataLen, uint8_t *data, uint32_t *dataLen);

typedef int32_t (*HITLS_AUTH_PrivPassSignData)(void *pkeyCtx, const uint8_t *data, uint32_t dataLen,
    uint8_t *sign, uint32_t *signLen);

typedef int32_t (*HITLS_AUTH_PrivPassVerify)(void *pkeyCtx, int32_t algId, const uint8_t *data, uint32_t dataLen,
    const uint8_t *sign, uint32_t signLen);

typedef int32_t (*HITLS_AUTH_PrivPassDecodePubKey)(void *libCtx, const char *attrName, uint8_t *pubKey,
    uint32_t pubKeyLen, void **pkeyCtx);

typedef int32_t (*HITLS_AUTH_PrivPassDecodePrvKey)(void *libCtx, const char *attrName, void *param, uint8_t *prvKey,
    uint32_t prvKeyLen, void **pkeyCtx);

typedef int32_t (*HITLS_AUTH_PrivPassCheckKeyPair)(void *pubKeyCtx, void *prvKeyCtx);

typedef int32_t (*HITLS_AUTH_PrivPassRandom)(uint8_t *buffer, uint32_t bufferLen);

HITLS_AUTH_PrivPassCtx *HITLS_AUTH_PrivPassNewCtx(int32_t protocolType);

void HITLS_AUTH_PrivPassFreeCtx(HITLS_AUTH_PrivPassCtx *ctx);
HITLS_AUTH_PrivPassToken *HITLS_AUTH_PrivPassNewToken(int32_t tokenType);

void HITLS_AUTH_PrivPassFreeToken(HITLS_AUTH_PrivPassToken *object);

int32_t HITLS_AUTH_PrivPassSetCryptCb(HITLS_AUTH_PrivPassCtx *ctx, int32_t cbType, void *cryptCb);

int32_t HITLS_AUTH_PrivPassSerialization(HITLS_AUTH_PrivPassCtx *ctx, const HITLS_AUTH_PrivPassToken *object,
    uint8_t *buffer, uint32_t *outBuffLen);

int32_t HITLS_AUTH_PrivPassDeserialization(HITLS_AUTH_PrivPassCtx *ctx, int32_t tokenType, const uint8_t *buffer,
    uint32_t buffLen, HITLS_AUTH_PrivPassToken **object);

int32_t HITLS_AUTH_PrivPassGenTokenChallenge(HITLS_AUTH_PrivPassCtx *ctx, const BSL_Param *param,
    HITLS_AUTH_PrivPassToken **challenge);

int32_t HITLS_AUTH_PrivPassGenTokenReq(HITLS_AUTH_PrivPassCtx *ctx, const HITLS_AUTH_PrivPassToken *tokenChallenge,
    HITLS_AUTH_PrivPassToken **tokenRequest);

int32_t HITLS_AUTH_PrivPassGenTokenResponse(HITLS_AUTH_PrivPassCtx *ctx, const HITLS_AUTH_PrivPassToken *tokenRequest,
    HITLS_AUTH_PrivPassToken **tokenResponse);

int32_t HITLS_AUTH_PrivPassGenToken(HITLS_AUTH_PrivPassCtx *ctx, const HITLS_AUTH_PrivPassToken *tokenChallenge,
    const HITLS_AUTH_PrivPassToken *tokenResponse, HITLS_AUTH_PrivPassToken **token);

int32_t HITLS_AUTH_PrivPassVerifyToken(HITLS_AUTH_PrivPassCtx *ctx, const HITLS_AUTH_PrivPassToken *tokenChallenge,
    const HITLS_AUTH_PrivPassToken *token);

int32_t HITLS_AUTH_PrivPassSetPubkey(HITLS_AUTH_PrivPassCtx *ctx, uint8_t *pki, uint32_t pkiLen);

int32_t HITLS_AUTH_PrivPassSetPrvkey(HITLS_AUTH_PrivPassCtx *ctx, void *param, uint8_t *ski, uint32_t skiLen);

int32_t HITLS_AUTH_PrivPassTokenCtrl(HITLS_AUTH_PrivPassToken *object, int32_t cmd, void *param, uint32_t paramLen);

int32_t HITLS_AUTH_PrivPassCtxCtrl(HITLS_AUTH_PrivPassCtx *ctx, int32_t cmd, void *param, uint32_t paramLen);
 
#ifdef __cplusplus
}
#endif
 
#endif // AUTH_PRIVPASS_TOKEN_H